akeyless_mcp 3.0.1

use rmcp::{
    ServerHandler, ServiceExt,
    handler::server::{router::tool::ToolRouter, wrapper::Parameters},
    model::{ServerCapabilities, ServerInfo},
    schemars, tool, tool_handler, tool_router,
    transport::stdio,
};
use serde::Deserialize;

use crate::auth;
use crate::client::AkeylessMcpClient;
use crate::config::AkeylessMcpConfig;
use crate::format;

// -- MCP tool input types --
//
// Each struct maps to an operation from the API spec. Field descriptions
// are preserved for schemars -> MCP tool schema generation.

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AccountCustomFieldCreateInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the custom field")]
    name: String,
    #[schemars(description = "The object to create the custom field")]
    object: String,
    #[schemars(description = "The object type to create the custom field [e.g. STATIC_SECRET,DYNAMIC_SECRET,ROTATED_SECRET]")]
    object_type: String,
    #[schemars(description = "Specify whether the custom field is mandatory")]
    required: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AccountCustomFieldDeleteInput {
    #[schemars(description = "The custom field id")]
    id: i64,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AccountCustomFieldGetInput {
    #[schemars(description = "The custom field id")]
    id: i64,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AccountCustomFieldListInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The object to filter by the custom fields in: body")]
    object: Option<String>,
    #[schemars(description = "The object type to filter by the custom fields in: body")]
    object_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AccountCustomFieldUpdateInput {
    #[schemars(description = "The custom field id")]
    id: i64,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The new name of the custom field")]
    name: Option<String>,
    #[schemars(description = "Specify whether the custom field is mandatory")]
    required: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AliasDetailsInput {
    #[schemars(description = "Account alias")]
    account_alias: String,
    #[schemars(description = "Auth method name")]
    auth_method_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AssocRoleAuthMethodInput {
    #[schemars(description = "The auth method to associate")]
    am_name: String,
    #[schemars(description = "Treat sub claims as case-sensitive [true/false]")]
    case_sensitive: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The role to associate")]
    role_name: String,
    #[schemars(description = "key/val of sub claims, e.g group=admins,developers")]
    sub_claims: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AssocTargetItemInput {
    #[schemars(description = "A path on the target to store the certificate pem file (relevant only for certificate provisioning)")]
    certificate_path: Option<String>,
    #[schemars(description = "A path on the target to store the full chain pem file (relevant only for certificate provisioning)")]
    chain_path: Option<String>,
    #[schemars(description = "Automatically disable previous key version (required for azure targets)")]
    disable_previous_key_version: Option<bool>,
    #[schemars(description = "The external key name to associate with the classic key (Relevant only for Classic Key AWS/Azure/GCP targets)")]
    external_key_name: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "A list of allowed operations for the key (required for azure targets)")]
    key_operations: Option<Vec<String>>,
    #[schemars(description = "Keyring name of the GCP KMS (required for gcp targets)")]
    keyring_name: Option<String>,
    #[schemars(description = "Algorithm of the key in GCP KMS (required for gcp targets)")]
    kms_algorithm: Option<String>,
    #[schemars(description = "Location id of the GCP KMS (required for gcp targets)")]
    location_id: Option<String>,
    #[schemars(description = "Set to 'true' to create a multi-region managed key. (Relevant only for Classic Key AWS targets)")]
    multi_region: Option<String>,
    #[schemars(description = "The item to associate")]
    name: String,
    #[schemars(description = "A custom command to run on the remote target after successful provisioning (relevant only for certificate provisioning)")]
    post_provision_command: Option<String>,
    #[schemars(description = "A path on the target to store the private key (relevant only for certificate provisioning)")]
    private_key_path: Option<String>,
    #[schemars(description = "Project id of the GCP KMS (required for gcp targets)")]
    project_id: Option<String>,
    #[schemars(description = "Protection level of the key [software/hardware] (relevant for gcp targets)")]
    protection_level: Option<String>,
    #[schemars(description = "Purpose of the key in GCP KMS (required for gcp targets)")]
    purpose: Option<String>,
    #[schemars(description = "The list of regions to create a copy of the key in (relevant for aws targets)")]
    regions: Option<Vec<String>>,
    #[schemars(description = "Is the target to associate is for sra, relevant only for linked target association for ldap rotated secret")]
    sra_association: Option<bool>,
    #[schemars(description = "The target to associate")]
    target_name: String,
    #[schemars(description = "The tenant secret type [Data/SearchIndex/Analytics] (required for salesforce targets)")]
    tenant_secret_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Name of the vault used (required for azure targets)")]
    vault_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthInput {
    #[schemars(description = "Access ID")]
    access_id: Option<String>,
    #[schemars(description = "Access key (relevant only for access-type=access_key)")]
    access_key: Option<String>,
    #[schemars(description = "Access Type (access_key/password/saml/ldap/k8s/azure_ad/oidc/aws_iam/universal_identity/jwt/gcp/cert/oci/kerberos)")]
    access_type: Option<String>,
    #[schemars(description = "Account id (relevant only for access-type=password where the email address is associated with more than one account)")]
    account_id: Option<String>,
    #[schemars(description = "Email (relevant only for access-type=password)")]
    admin_email: Option<String>,
    #[schemars(description = "Password (relevant only for access-type=password)")]
    admin_password: Option<String>,
    #[schemars(description = "Azure cloud environment to use. Values: AzureCloud (default), AzureUSGovernment, AzureChinaCloud.")]
    azure_cloud: Option<String>,
    #[schemars(description = "Certificate challenge encoded in base64. (relevant only for access-type=cert)")]
    cert_challenge: Option<String>,
    #[schemars(description = "Certificate data encoded in base64. Used if file was not provided. (relevant only for access-type=cert)")]
    cert_data: Option<String>,
    #[schemars(description = "The cloud identity (relevant only for access-type=azure_ad,aws_iam,gcp)")]
    cloud_id: Option<String>,
    debug: Option<bool>,
    #[schemars(description = "Disable the FAST negotiation in the Kerberos authentication method")]
    disable_pafxfast: Option<String>,
    #[schemars(description = "The service principal name of the gateway as registered in LDAP (i.e., HTTP/gateway)")]
    gateway_spn: Option<String>,
    #[schemars(description = "Gateway URL relevant only for access-type=k8s/oauth2/saml/oidc")]
    gateway_url: Option<String>,
    #[schemars(description = "GCP JWT audience")]
    gcp_audience: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The Json Web Token (relevant only for access-type=jwt/oidc)")]
    jwt: Option<String>,
    #[schemars(description = "The K8S Auth config name (relevant only for access-type=k8s)")]
    k8s_auth_config_name: Option<String>,
    #[schemars(description = "The K8S service account token. (relevant only for access-type=k8s)")]
    k8s_service_account_token: Option<String>,
    #[schemars(description = "KerberosToken represents a Kerberos token generated for the gateway SPN (Service Principal Name).")]
    kerberos_token: Option<String>,
    #[schemars(description = "TThe username for the entry within the keytab to authenticate via Kerberos")]
    kerberos_username: Option<String>,
    #[schemars(description = "Private key data encoded in base64. Used if file was not provided.(relevant only for access-type=cert)")]
    key_data: Option<String>,
    #[schemars(description = "Base64-encoded content of a valid keytab file, containing the service account's entry.")]
    keytab_data: Option<String>,
    #[schemars(description = "Base64-encoded content of a valid krb5.conf file, specifying the settings and parameters required for Kerberos authentication.")]
    krb5_conf_data: Option<String>,
    #[schemars(description = "LDAP password (relevant only for access-type=ldap)")]
    ldap_password: Option<String>,
    #[schemars(description = "The type of the OCI configuration to use [instance/apikey/resource] (relevant only for access-type=oci)")]
    oci_auth_type: Option<String>,
    #[schemars(description = "A list of Oracle Cloud IDs groups (relevant only for access-type=oci)")]
    oci_group_ocid: Option<Vec<String>>,
    otp: Option<String>,
    #[schemars(description = "Signed certificate challenge encoded in base64. (relevant only for access-type=cert)")]
    signed_cert_challenge: Option<String>,
    #[schemars(description = "The universal_identity token (relevant only for access-type=universal_identity)")]
    uid_token: Option<String>,
    #[schemars(description = "Returns a link to complete the authentication remotely (relevant only for access-type=saml/oidc)")]
    use_remote_browser: Option<bool>,
    #[schemars(description = "LDAP username (relevant only for access-type=ldap)")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateApiKeyInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateAwsIamInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of full arns that the access is restricted to")]
    bound_arn: Option<Vec<String>>,
    #[schemars(description = "A list of AWS account-IDs that the access is restricted to")]
    bound_aws_account_id: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role ids that the access is restricted to")]
    bound_role_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role-name that the access is restricted to")]
    bound_role_name: Option<Vec<String>>,
    #[schemars(description = "A list of full user ids that the access is restricted to")]
    bound_user_id: Option<Vec<String>>,
    #[schemars(description = "A list of full user-name that the access is restricted to")]
    bound_user_name: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "sts URL")]
    sts_url: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateAzureAdInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Deprecated (Deprecated) The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of group ids that the access is restricted to")]
    bound_group_id: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of resource providers that the access is restricted to (e.g, Microsoft.Compute, Microsoft.ManagedIdentity, etc)")]
    bound_providers: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of resource names that the access is restricted to (e.g, a virtual machine name, scale set name, etc).")]
    bound_resource_names: Option<Vec<String>>,
    #[schemars(description = "A list of resource types that the access is restricted to (e.g, virtualMachines, userAssignedIdentities, etc)")]
    bound_resource_types: Option<Vec<String>>,
    #[schemars(description = "A list of resource groups that the access is restricted to")]
    bound_rg_id: Option<Vec<String>>,
    #[schemars(description = "A list of service principal IDs that the access is restricted to")]
    bound_spid: Option<Vec<String>>,
    #[schemars(description = "A list of subscription ids that the access is restricted to")]
    bound_sub_id: Option<Vec<String>>,
    #[schemars(description = "The Azure tenant id that the access is restricted to")]
    bound_tenant_id: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateCertInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Comma separated list of allowed CORS domains to be validated as part of the authentication flow.")]
    allowed_cors: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of names. At least one must exist in the Common Name. Supports globbing.")]
    bound_common_names: Option<Vec<String>>,
    #[schemars(description = "A list of DNS names. At least one must exist in the SANs. Supports globbing.")]
    bound_dns_sans: Option<Vec<String>>,
    #[schemars(description = "A list of Email Addresses. At least one must exist in the SANs. Supports globbing.")]
    bound_email_sans: Option<Vec<String>>,
    #[schemars(description = "A list of extensions formatted as \"oid:value\". Expects the extension value to be some type of ASN1 encoded string. All values much match. Supports globbing on \"value\".")]
    bound_extensions: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of Organizational Units names. At least one must exist in the OU field.")]
    bound_organizational_units: Option<Vec<String>>,
    #[schemars(description = "A list of URIs. At least one must exist in the SANs. Supports globbing.")]
    bound_uri_sans: Option<Vec<String>>,
    #[schemars(description = "The certificate data in base64, if no file was provided")]
    certificate_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Require certificate CRL distribution points (CDP) and enforce CRL validation during authentication.")]
    require_crl_dp: Option<bool>,
    #[schemars(description = "A list of revoked cert ids")]
    revoked_cert_ids: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured, such as common_name or organizational_unit Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateEmailInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "An email address to be invited to have access")]
    email: String,
    #[schemars(description = "Enable MFA for this authentication method [True / False]")]
    enable_mfa: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Enable two-factor-authentication via [email/auth app]")]
    mfa_type: Option<String>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateGcpInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience to verify in the JWT received by the client")]
    audience: String,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A comma-separated list of GCP labels formatted as \"key:value\" strings that must be set on authorized GCE instances. TODO: Because GCP labels are not currently ACL'd ....")]
    bound_labels: Option<Vec<String>>,
    #[schemars(description = "=== Human and Machine authentication section === Array of GCP project IDs. Only entities belonging to any of the provided projects can authenticate.")]
    bound_projects: Option<Vec<String>>,
    #[schemars(description = "List of regions that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a regional group and the group must belong to this region. If bound_zones are provided, this attribute is ignored.")]
    bound_regions: Option<Vec<String>>,
    #[schemars(description = "List of service accounts the service account must be part of in order to be authenticated.")]
    bound_service_accounts: Option<Vec<String>>,
    #[schemars(description = "=== Machine authentication section === List of zones that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a zonal group and the group must belong to this zone.")]
    bound_zones: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "ServiceAccount credentials data instead of giving a file path, base64 encoded")]
    service_account_creds_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Type of the GCP Access Rules")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateK8sInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the Kubernetes JWT that the access is restricted to")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of namespaces that the access is restricted to")]
    bound_namespaces: Option<Vec<String>>,
    #[schemars(description = "A list of pod names that the access is restricted to")]
    bound_pod_names: Option<Vec<String>>,
    #[schemars(description = "A list of service account names that the access is restricted to")]
    bound_sa_names: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for K8S configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Base64-encoded or PEM formatted public key data for K8S authentication method is required [RSA2048]")]
    public_key: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateKerberosInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    bind_dn: Option<String>,
    bind_dn_password: Option<String>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    group_attr: Option<String>,
    group_dn: Option<String>,
    group_filter: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    keytab_file_data: Option<String>,
    keytab_file_path: Option<String>,
    krb5_conf_data: Option<String>,
    krb5_conf_path: Option<String>,
    ldap_anonymous_search: Option<bool>,
    ldap_ca_cert: Option<String>,
    ldap_url: Option<String>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
    user_attribute: Option<String>,
    user_dn: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateLdapInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for LDAP configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A public key generated for LDAP authentication method on Akeyless in base64 or PEM format [RSA2048]")]
    public_key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateOauth2Input {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "The clients ids that the access is restricted to")]
    bound_client_ids: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "CertificateFile Path to a file that contain the certificate in a PEM format.")]
    cert: Option<String>,
    #[schemars(description = "CertificateFileData PEM Certificate in a Base64 format.")]
    cert_file_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Akeyless Gateway URL (Configuration Management port). Relevant only when the jwks-uri is accessible only from the gateway.")]
    gateway_url: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server. base64 encoded string")]
    jwks_json_data: Option<String>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateOciInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A list of required groups ocids")]
    group_ocid: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "The Oracle Cloud tenant ID")]
    tenant_ocid: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateOidcInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Audience claim to be used as part of the authentication flow. In case set, it must match the one configured on the Identity Provider's Application")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Client ID")]
    client_id: Option<String>,
    #[schemars(description = "Client Secret")]
    client_secret: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "RequiredScopes is a list of required scopes that the oidc method will request from the oidc provider and the user must approve")]
    required_scopes: Option<Vec<String>>,
    #[schemars(description = "RequiredScopesPrefix is a a prefix to add to all required-scopes when requesting them from the oidc server (for example, azures' Application ID URI)")]
    required_scopes_prefix: Option<String>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OIDC, OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateSamlInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "IDP metadata url")]
    idp_metadata_url: Option<String>,
    #[schemars(description = "IDP metadata xml data")]
    idp_metadata_xml_data: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodCreateUniversalIdentityInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Deny from root to create children")]
    deny_inheritance: Option<bool>,
    #[schemars(description = "Deny from the token to rotate")]
    deny_rotate: Option<bool>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token ttl")]
    ttl: Option<i64>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodDeleteInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodGetInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodListInput {
    #[schemars(description = "Filter by auth method name or part of it")]
    filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Next page reference")]
    pagination_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The Auth method types list of the requested method. In case it is empty, all types of auth methods will be returned. options: [api_key, azure_ad, oauth2/jwt, saml2, ldap, aws_iam, oidc, universal_identity, gcp, k8s, cert]")]
    type: Option<Vec<String>>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateApiKeyInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateAwsIamInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of full arns that the access is restricted to")]
    bound_arn: Option<Vec<String>>,
    #[schemars(description = "A list of AWS account-IDs that the access is restricted to")]
    bound_aws_account_id: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role ids that the access is restricted to")]
    bound_role_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role-name that the access is restricted to")]
    bound_role_name: Option<Vec<String>>,
    #[schemars(description = "A list of full user ids that the access is restricted to")]
    bound_user_id: Option<Vec<String>>,
    #[schemars(description = "A list of full user-name that the access is restricted to")]
    bound_user_name: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "sts URL")]
    sts_url: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateAzureAdInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Deprecated (Deprecated) The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of group ids that the access is restricted to")]
    bound_group_id: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of resource providers that the access is restricted to (e.g, Microsoft.Compute, Microsoft.ManagedIdentity, etc)")]
    bound_providers: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of resource names that the access is restricted to (e.g, a virtual machine name, scale set name, etc).")]
    bound_resource_names: Option<Vec<String>>,
    #[schemars(description = "A list of resource types that the access is restricted to (e.g, virtualMachines, userAssignedIdentities, etc)")]
    bound_resource_types: Option<Vec<String>>,
    #[schemars(description = "A list of resource groups that the access is restricted to")]
    bound_rg_id: Option<Vec<String>>,
    #[schemars(description = "A list of service principal IDs that the access is restricted to")]
    bound_spid: Option<Vec<String>>,
    #[schemars(description = "A list of subscription ids that the access is restricted to")]
    bound_sub_id: Option<Vec<String>>,
    #[schemars(description = "The Azure tenant id that the access is restricted to")]
    bound_tenant_id: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateCertInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Comma separated list of allowed CORS domains to be validated as part of the authentication flow.")]
    allowed_cors: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of names. At least one must exist in the Common Name. Supports globbing.")]
    bound_common_names: Option<Vec<String>>,
    #[schemars(description = "A list of DNS names. At least one must exist in the SANs. Supports globbing.")]
    bound_dns_sans: Option<Vec<String>>,
    #[schemars(description = "A list of Email Addresses. At least one must exist in the SANs. Supports globbing.")]
    bound_email_sans: Option<Vec<String>>,
    #[schemars(description = "A list of extensions formatted as \"oid:value\". Expects the extension value to be some type of ASN1 encoded string. All values much match. Supports globbing on \"value\".")]
    bound_extensions: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of Organizational Units names. At least one must exist in the OU field.")]
    bound_organizational_units: Option<Vec<String>>,
    #[schemars(description = "A list of URIs. At least one must exist in the SANs. Supports globbing.")]
    bound_uri_sans: Option<Vec<String>>,
    #[schemars(description = "The certificate data in base64, if no file was provided")]
    certificate_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Require certificate CRL distribution points (CDP) and enforce CRL validation during authentication.")]
    require_crl_dp: Option<bool>,
    #[schemars(description = "A list of revoked cert ids")]
    revoked_cert_ids: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured, such as common_name or organizational_unit Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateEmailInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "Enable MFA for this authentication method [True / False]")]
    enable_mfa: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Enable two-factor-authentication via [email/auth app]")]
    mfa_type: Option<String>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateGcpInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience to verify in the JWT received by the client")]
    audience: String,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A comma-separated list of GCP labels formatted as \"key:value\" strings that must be set on authorized GCE instances. TODO: Because GCP labels are not currently ACL'd ....")]
    bound_labels: Option<Vec<String>>,
    #[schemars(description = "=== Human and Machine authentication section === Array of GCP project IDs. Only entities belonging to any of the provided projects can authenticate.")]
    bound_projects: Option<Vec<String>>,
    #[schemars(description = "List of regions that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a regional group and the group must belong to this region. If bound_zones are provided, this attribute is ignored.")]
    bound_regions: Option<Vec<String>>,
    #[schemars(description = "List of service accounts the service account must be part of in order to be authenticated.")]
    bound_service_accounts: Option<Vec<String>>,
    #[schemars(description = "=== Machine authentication section === List of zones that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a zonal group and the group must belong to this zone.")]
    bound_zones: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "ServiceAccount credentials data instead of giving a file path, base64 encoded")]
    service_account_creds_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Type of the GCP Access Rules")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateK8sInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the Kubernetes JWT that the access is restricted to")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of namespaces that the access is restricted to")]
    bound_namespaces: Option<Vec<String>>,
    #[schemars(description = "A list of pod names that the access is restricted to")]
    bound_pod_names: Option<Vec<String>>,
    #[schemars(description = "A list of service account names that the access is restricted to")]
    bound_sa_names: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for K8S configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Base64-encoded or PEM formatted public key data for K8S authentication method is required [RSA2048]")]
    public_key: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateKerberosInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    bind_dn: Option<String>,
    bind_dn_password: Option<String>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    group_attr: Option<String>,
    group_dn: Option<String>,
    group_filter: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    keytab_file_data: Option<String>,
    keytab_file_path: Option<String>,
    krb5_conf_data: Option<String>,
    krb5_conf_path: Option<String>,
    ldap_anonymous_search: Option<bool>,
    ldap_ca_cert: Option<String>,
    ldap_url: Option<String>,
    #[schemars(description = "Auth Method name")]
    name: String,
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
    user_attribute: Option<String>,
    user_dn: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateLdapInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for LDAP configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A public key generated for LDAP authentication method on Akeyless in base64 or PEM format [RSA2048]")]
    public_key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateOauth2Input {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "The clients ids that the access is restricted to")]
    bound_client_ids: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "CertificateFile Path to a file that contain the certificate in a PEM format.")]
    cert: Option<String>,
    #[schemars(description = "CertificateFileData PEM Certificate in a Base64 format.")]
    cert_file_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Akeyless Gateway URL (Configuration Management port). Relevant only when the jwks-uri is accessible only from the gateway.")]
    gateway_url: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server. base64 encoded string")]
    jwks_json_data: Option<String>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateOciInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A list of required groups ocids")]
    group_ocid: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "The Oracle Cloud tenant ID")]
    tenant_ocid: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateOidcInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Audience claim to be used as part of the authentication flow. In case set, it must match the one configured on the Identity Provider's Application")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Client ID")]
    client_id: Option<String>,
    #[schemars(description = "Client Secret")]
    client_secret: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "RequiredScopes is a list of required scopes that the oidc method will request from the oidc provider and the user must approve")]
    required_scopes: Option<Vec<String>>,
    #[schemars(description = "RequiredScopesPrefix is a a prefix to add to all required-scopes when requesting them from the oidc server (for example, azures' Application ID URI)")]
    required_scopes_prefix: Option<String>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OIDC, OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateSamlInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "IDP metadata url")]
    idp_metadata_url: Option<String>,
    #[schemars(description = "IDP metadata xml data")]
    idp_metadata_xml_data: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct AuthMethodUpdateUniversalIdentityInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Deny from root to create children")]
    deny_inheritance: Option<bool>,
    #[schemars(description = "Deny from the token to rotate")]
    deny_rotate: Option<bool>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token ttl")]
    ttl: Option<i64>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CalcPasswordSecurityInfoInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    min_length: Option<i64>,
    password: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CertificateDiscoveryInput {
    #[schemars(description = "Debug mode")]
    debug: Option<bool>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "A comma separated list of IPs, CIDR ranges, or DNS names to discovery")]
    hosts: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "A comma separated list of port ranges Examples: \"80,443\" or \"80,443,8080-8090\" or \"443\"")]
    port_ranges: Option<String>,
    #[schemars(description = "The name of the key that protects the certificate value")]
    protection_key: Option<String>,
    #[schemars(description = "The folder where the results will be saved")]
    target_location: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ChangeAdminAccountPasswordInput {
    #[schemars(description = "Current password")]
    current_password: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "New password")]
    new_password: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ConfigureInput {
    #[schemars(description = "Access ID")]
    access_id: Option<String>,
    #[schemars(description = "Access Key")]
    access_key: Option<String>,
    #[schemars(description = "Access Type (access_key/password/azure_ad/saml/oidc/aws_iam/gcp/k8s/cert)")]
    access_type: Option<String>,
    #[schemars(description = "Account id (relevant only for access-type=password where the email address is associated with more than one account)")]
    account_id: Option<String>,
    #[schemars(description = "Email (relevant only for access-type=password)")]
    admin_email: Option<String>,
    #[schemars(description = "Password (relevant only for access-type=password)")]
    admin_password: Option<String>,
    #[schemars(description = "Azure Active Directory ObjectId (relevant only for access-type=azure_ad)")]
    azure_ad_object_id: Option<String>,
    #[schemars(description = "Azure cloud environment to use. Values: AzureCloud (default), AzureUSGovernment, AzureChinaCloud.")]
    azure_cloud: Option<String>,
    #[schemars(description = "Certificate data encoded in base64. Used if file was not provided. (relevant only for access-type=cert in Curl Context)")]
    cert_data: Option<String>,
    #[schemars(description = "Certificate Issuer Name")]
    cert_issuer_name: Option<String>,
    #[schemars(description = "The username to sign in the SSH certificate (use a comma-separated list for more than one username)")]
    cert_username: Option<String>,
    #[schemars(description = "Default path prefix for name of items, targets and auth methods")]
    default_location_prefix: Option<String>,
    #[schemars(description = "Disable the FAST negotiation in the Kerberos authentication method")]
    disable_pafxfast: Option<String>,
    #[schemars(description = "The service principal name of the gateway as registered in LDAP (i.e., HTTP/gateway)")]
    gateway_spn: Option<String>,
    #[schemars(description = "GCP JWT audience")]
    gcp_audience: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The K8S Auth config name (relevant only for access-type=k8s)")]
    k8s_auth_config_name: Option<String>,
    #[schemars(description = "KerberosToken represents a Kerberos token generated for the gateway SPN (Service Principal Name).")]
    kerberos_token: Option<String>,
    #[schemars(description = "TThe username for the entry within the keytab to authenticate via Kerberos")]
    kerberos_username: Option<String>,
    #[schemars(description = "Private key data encoded in base64. Used if file was not provided.(relevant only for access-type=cert in Curl Context)")]
    key_data: Option<String>,
    #[schemars(description = "Base64-encoded content of a valid keytab file, containing the service account's entry.")]
    keytab_data: Option<String>,
    #[schemars(description = "Base64-encoded content of a valid krb5.conf file, specifying the settings and parameters required for Kerberos authentication.")]
    krb5_conf_data: Option<String>,
    #[schemars(description = "Set this option to output legacy ('ssh-rsa-cert-v01@openssh.com') signing algorithm name in the certificate.")]
    legacy_signing_alg_name: Option<bool>,
    #[schemars(description = "The type of the OCI configuration to use [instance/apikey/resource] (relevant only for access-type=oci)")]
    oci_auth_type: Option<String>,
    #[schemars(description = "A list of Oracle Cloud IDs groups (relevant only for access-type=oci)")]
    oci_group_ocid: Option<Vec<String>>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ConnectInput {
    helper: Option<serde_json::Value>,
    #[schemars(description = "used to override .akeyless-connect.rc in tests")]
    rc_file_override: Option<String>,
    #[schemars(description = "Deprecated. use bastion-ctrl-path")]
    bastion_ctrl_path: Option<String>,
    #[schemars(description = "Deprecated. use sra-ctrl-port")]
    bastion_ctrl_port: Option<String>,
    #[schemars(description = "Deprecated. use sra-ctrl-proto")]
    bastion_ctrl_proto: Option<String>,
    #[schemars(description = "Deprecated. use sra-ctrl-subdomain")]
    bastion_ctrl_subdomain: Option<String>,
    #[schemars(description = "The Akeyless certificate issuer name")]
    cert_issuer_name: Option<String>,
    #[schemars(description = "The Gateway URL (configuration management) address, e.g. http://localhost:8000")]
    gateway_url: Option<String>,
    #[schemars(description = "The file from which the identity (private key) for public key authentication is read")]
    identity_file: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    justification: Option<String>,
    #[schemars(description = "The Secret name (for database and AWS producers - producer name)")]
    name: Option<String>,
    #[schemars(description = "The Bastion API path")]
    sra_ctrl_path: Option<String>,
    #[schemars(description = "The Bastion API Port")]
    sra_ctrl_port: Option<String>,
    #[schemars(description = "The SRA API protocol")]
    sra_ctrl_proto: Option<String>,
    #[schemars(description = "The SRA API prefix")]
    sra_ctrl_subdomain: Option<String>,
    #[schemars(description = "Path to SSH executable. e.g. /usr/bin/ssh")]
    ssh_command: Option<String>,
    #[schemars(description = "Additional SSH arguments (except -i)")]
    ssh_extra_args: Option<String>,
    #[schemars(description = "Set this option to output legacy ('ssh-rsa-cert-v01@openssh.com') signing algorithm name in the ssh certificate.")]
    ssh_legacy_signing_alg: Option<bool>,
    #[schemars(description = "The target")]
    target: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    use_ssh_agent: Option<bool>,
    #[schemars(description = "Deprecated. Use via-sra")]
    via_bastion: Option<String>,
    #[schemars(description = "The jump box server")]
    via_sra: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateArtifactoryTargetInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: String,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: String,
    #[schemars(description = "Base URL")]
    base_url: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodAwsiamInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of full arns that the access is restricted to")]
    bound_arn: Option<Vec<String>>,
    #[schemars(description = "A list of AWS account-IDs that the access is restricted to")]
    bound_aws_account_id: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role ids that the access is restricted to")]
    bound_role_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role-name that the access is restricted to")]
    bound_role_name: Option<Vec<String>>,
    #[schemars(description = "A list of full user ids that the access is restricted to")]
    bound_user_id: Option<Vec<String>>,
    #[schemars(description = "A list of full user-name that the access is restricted to")]
    bound_user_name: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "sts URL")]
    sts_url: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodAzureAdInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Deprecated (Deprecated) The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of group ids that the access is restricted to")]
    bound_group_id: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of resource providers that the access is restricted to (e.g, Microsoft.Compute, Microsoft.ManagedIdentity, etc)")]
    bound_providers: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of resource names that the access is restricted to (e.g, a virtual machine name, scale set name, etc).")]
    bound_resource_names: Option<Vec<String>>,
    #[schemars(description = "A list of resource types that the access is restricted to (e.g, virtualMachines, userAssignedIdentities, etc)")]
    bound_resource_types: Option<Vec<String>>,
    #[schemars(description = "A list of resource groups that the access is restricted to")]
    bound_rg_id: Option<Vec<String>>,
    #[schemars(description = "A list of service principal IDs that the access is restricted to")]
    bound_spid: Option<Vec<String>>,
    #[schemars(description = "A list of subscription ids that the access is restricted to")]
    bound_sub_id: Option<Vec<String>>,
    #[schemars(description = "The Azure tenant id that the access is restricted to")]
    bound_tenant_id: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodCertInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Comma separated list of allowed CORS domains to be validated as part of the authentication flow.")]
    allowed_cors: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of names. At least one must exist in the Common Name. Supports globbing.")]
    bound_common_names: Option<Vec<String>>,
    #[schemars(description = "A list of DNS names. At least one must exist in the SANs. Supports globbing.")]
    bound_dns_sans: Option<Vec<String>>,
    #[schemars(description = "A list of Email Addresses. At least one must exist in the SANs. Supports globbing.")]
    bound_email_sans: Option<Vec<String>>,
    #[schemars(description = "A list of extensions formatted as \"oid:value\". Expects the extension value to be some type of ASN1 encoded string. All values much match. Supports globbing on \"value\".")]
    bound_extensions: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of Organizational Units names. At least one must exist in the OU field.")]
    bound_organizational_units: Option<Vec<String>>,
    #[schemars(description = "A list of URIs. At least one must exist in the SANs. Supports globbing.")]
    bound_uri_sans: Option<Vec<String>>,
    #[schemars(description = "The certificate data in base64, if no file was provided")]
    certificate_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Require certificate CRL distribution points (CDP) and enforce CRL validation during authentication.")]
    require_crl_dp: Option<bool>,
    #[schemars(description = "A list of revoked cert ids")]
    revoked_cert_ids: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured, such as common_name or organizational_unit Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodEmailInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "An email address to be invited to have access")]
    email: String,
    #[schemars(description = "Enable MFA for this authentication method [True / False]")]
    enable_mfa: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Enable two-factor-authentication via [email/auth app]")]
    mfa_type: Option<String>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodGcpInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience to verify in the JWT received by the client")]
    audience: String,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A comma-separated list of GCP labels formatted as \"key:value\" strings that must be set on authorized GCE instances. TODO: Because GCP labels are not currently ACL'd ....")]
    bound_labels: Option<Vec<String>>,
    #[schemars(description = "=== Human and Machine authentication section === Array of GCP project IDs. Only entities belonging to any of the provided projects can authenticate.")]
    bound_projects: Option<Vec<String>>,
    #[schemars(description = "List of regions that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a regional group and the group must belong to this region. If bound_zones are provided, this attribute is ignored.")]
    bound_regions: Option<Vec<String>>,
    #[schemars(description = "List of service accounts the service account must be part of in order to be authenticated.")]
    bound_service_accounts: Option<Vec<String>>,
    #[schemars(description = "=== Machine authentication section === List of zones that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a zonal group and the group must belong to this zone.")]
    bound_zones: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "ServiceAccount credentials data instead of giving a file path, base64 encoded")]
    service_account_creds_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Type of the GCP Access Rules")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodHuaweiInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "sts URL")]
    auth_url: Option<String>,
    #[schemars(description = "A list of domain IDs that the access is restricted to")]
    bound_domain_id: Option<Vec<String>>,
    #[schemars(description = "A list of domain names that the access is restricted to")]
    bound_domain_name: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of full tenant ids that the access is restricted to")]
    bound_tenant_id: Option<Vec<String>>,
    #[schemars(description = "A list of full tenant names that the access is restricted to")]
    bound_tenant_name: Option<Vec<String>>,
    #[schemars(description = "A list of full user ids that the access is restricted to")]
    bound_user_id: Option<Vec<String>>,
    #[schemars(description = "A list of full user-name that the access is restricted to")]
    bound_user_name: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodK8sInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the Kubernetes JWT that the access is restricted to")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of namespaces that the access is restricted to")]
    bound_namespaces: Option<Vec<String>>,
    #[schemars(description = "A list of pod names that the access is restricted to")]
    bound_pod_names: Option<Vec<String>>,
    #[schemars(description = "A list of service account names that the access is restricted to")]
    bound_sa_names: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for K8S configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Base64-encoded or PEM formatted public key data for K8S authentication method is required [RSA2048]")]
    public_key: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodLdapInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for LDAP configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A public key generated for LDAP authentication method on Akeyless in base64 or PEM format [RSA2048]")]
    public_key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodOAuth2Input {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "The clients ids that the access is restricted to")]
    bound_client_ids: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "CertificateFile Path to a file that contain the certificate in a PEM format.")]
    cert: Option<String>,
    #[schemars(description = "CertificateFileData PEM Certificate in a Base64 format.")]
    cert_file_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Akeyless Gateway URL (Configuration Management port). Relevant only when the jwks-uri is accessible only from the gateway.")]
    gateway_url: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server. base64 encoded string")]
    jwks_json_data: Option<String>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodOciInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A list of required groups ocids")]
    group_ocid: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "The Oracle Cloud tenant ID")]
    tenant_ocid: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodOidcInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Audience claim to be used as part of the authentication flow. In case set, it must match the one configured on the Identity Provider's Application")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Client ID")]
    client_id: Option<String>,
    #[schemars(description = "Client Secret")]
    client_secret: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "RequiredScopes is a list of required scopes that the oidc method will request from the oidc provider and the user must approve")]
    required_scopes: Option<Vec<String>>,
    #[schemars(description = "RequiredScopesPrefix is a a prefix to add to all required-scopes when requesting them from the oidc server (for example, azures' Application ID URI)")]
    required_scopes_prefix: Option<String>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OIDC, OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodSamlInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "IDP metadata url")]
    idp_metadata_url: Option<String>,
    #[schemars(description = "IDP metadata xml data")]
    idp_metadata_xml_data: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAuthMethodUniversalIdentityInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Deny from root to create children")]
    deny_inheritance: Option<bool>,
    #[schemars(description = "Deny from the token to rotate")]
    deny_rotate: Option<bool>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token ttl")]
    ttl: Option<i64>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAwsTargetInput {
    #[schemars(description = "AWS secret access key")]
    access_key: String,
    #[schemars(description = "AWS access key ID")]
    access_key_id: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A unique auto-generated value used in your AWS account when configuring your AWS IAM role to securely delegate access to Akeyless. Relevant only when using GW cloud ID")]
    generate_external_id: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "AWS region")]
    region: Option<String>,
    #[schemars(description = "AWS IAM role identifier that Gateway will assume in your AWS account, relevant only when using external ID")]
    role_arn: Option<String>,
    #[schemars(description = "Required only for temporary security credentials retrieved using STS")]
    session_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateAzureTargetInput {
    #[schemars(description = "Azure cloud environment to use. Values: AzureCloud (default), AzureUSGovernment, AzureChinaCloud.")]
    azure_cloud: Option<String>,
    #[schemars(description = "Azure client/application id")]
    client_id: Option<String>,
    #[schemars(description = "Azure client secret")]
    client_secret: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Type of connection [credentials/cloud-identity]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "The Resource Group name in your Azure subscription")]
    resource_group_name: Option<String>,
    #[schemars(description = "The name of the relevant Resource")]
    resource_name: Option<String>,
    #[schemars(description = "Azure Subscription Id")]
    subscription_id: Option<String>,
    #[schemars(description = "Azure tenant id")]
    tenant_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM [Deprecated: Use connection-type=cloud-identity]")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateCertificateInput {
    #[schemars(description = "Content of the certificate in a Base64 format.")]
    certificate_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "CertificateFormat of the certificate and private key, possible values: cer,crt,pem,pfx,p12. Required when passing inline certificate content with --certificate-data or --key-data, otherwise format is derived from the file extension.")]
    format: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key to use to encrypt the certificate's key (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Content of the certificate's private key in a Base64 format.")]
    key_data: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "Certificate name")]
    name: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateClassicKeyInput {
    #[schemars(description = "Classic Key type; options: [AES128GCM, AES256GCM, AES128SIV, AES256SIV, RSA1024, RSA2048, RSA3072, RSA4096, EC256, EC384, GPG]")]
    alg: String,
    #[schemars(description = "Whether to automatically rotate every rotation_interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Certificate in a PEM format.")]
    cert_file_data: Option<String>,
    #[schemars(description = "Common name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_common_name: Option<String>,
    #[schemars(description = "Country name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_country: Option<String>,
    #[schemars(description = "Digest algorithm to be used for the certificate key signing.")]
    certificate_digest_algo: Option<String>,
    certificate_format: Option<String>,
    #[schemars(description = "Locality for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_locality: Option<String>,
    #[schemars(description = "Organization name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_organization: Option<String>,
    #[schemars(description = "Province name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_province: Option<String>,
    #[schemars(description = "TTL in days for the generated certificate. Required only for generate-self-signed-certificate.")]
    certificate_ttl: Option<i64>,
    #[schemars(description = "The csr config data in base64 encoding")]
    conf_file_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Whether to generate a self signed certificate with the key. If set, --certificate-ttl must be provided.")]
    generate_self_signed_certificate: Option<bool>,
    #[schemars(description = "gpg alg: Relevant only if GPG key type selected; options: [RSA1024, RSA2048, RSA3072, RSA4096, Ed25519]")]
    gpg_alg: Option<String>,
    #[schemars(description = "Specifies the hash algorithm used for the encryption key's operations, available options: [SHA256, SHA384, SHA512]")]
    hash_algorithm: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Base64-encoded classic key value")]
    key_data: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "ClassicKey name")]
    name: String,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    protection_key_name: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The number of days to wait between every automatic rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateDbTargetInput {
    #[schemars(description = "(Optional) Client id (relevant for \"cloud-service-provider\" only)")]
    azure_client_id: Option<String>,
    #[schemars(description = "(Optional) Client secret (relevant for \"cloud-service-provider\" only)")]
    azure_client_secret: Option<String>,
    #[schemars(description = "(Optional) Tenant id (relevant for \"cloud-service-provider\" only)")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "(Optional) Cloud service provider (currently only supports Azure)")]
    cloud_service_provider: Option<String>,
    #[schemars(description = "Cluster Mode")]
    cluster_mode: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Type of connection to mssql database [credentials/cloud-identity/wallet/parent-target]")]
    connection_type: String,
    db_name: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    db_type: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    mongodb_atlas: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Oracle db service name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Wallet login type (password/mtls)")]
    oracle_wallet_login_type: Option<String>,
    #[schemars(description = "Oracle wallet p12 file data in base64")]
    oracle_wallet_p12_file_data: Option<String>,
    #[schemars(description = "Oracle wallet sso file data in base64")]
    oracle_wallet_sso_file_data: Option<String>,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    port: Option<String>,
    pwd: Option<String>,
    snowflake_account: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    snowflake_api_private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    snowflake_api_private_key_password: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    user_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateDfcKeyInput {
    #[schemars(description = "DFCKey type; options: [AES128GCM, AES256GCM, AES128SIV, AES256SIV, AES128CBC, AES256CBC, RSA1024, RSA2048, RSA3072, RSA4096]")]
    alg: String,
    #[schemars(description = "Whether to automatically rotate every rotation_interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Common name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_common_name: Option<String>,
    #[schemars(description = "Country name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_country: Option<String>,
    #[schemars(description = "Digest algorithm to be used for the certificate key signing.")]
    certificate_digest_algo: Option<String>,
    certificate_format: Option<String>,
    #[schemars(description = "Locality for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_locality: Option<String>,
    #[schemars(description = "Organization name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_organization: Option<String>,
    #[schemars(description = "Province name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_province: Option<String>,
    #[schemars(description = "TTL in days for the generated certificate. Required only for generate-self-signed-certificate.")]
    certificate_ttl: Option<i64>,
    #[schemars(description = "The csr config data in base64 encoding")]
    conf_file_data: Option<String>,
    #[schemars(description = "The customer fragment ID that will be used to create the DFC key (if empty, the key will be created independently of a customer fragment)")]
    customer_frg_id: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Whether to generate a self signed certificate with the key. If set, --certificate-ttl must be provided.")]
    generate_self_signed_certificate: Option<bool>,
    #[schemars(description = "Specifies the hash algorithm used for the encryption key's operations, available options: [SHA256, SHA384, SHA512]")]
    hash_algorithm: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "DFCKey name")]
    name: String,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The number of days to wait between every automatic rotation (7-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The number of fragments that the item will be split into (not includes customer fragment)")]
    split_level: Option<i64>,
    #[schemars(description = "List of the tags attached to this DFC key")]
    tag: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateDockerhubTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Password for docker repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Username for docker repository")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateDynamicSecretInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the dynamic secret values (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateEksTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: String,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: String,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: String,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: String,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateEsmInput {
    #[schemars(description = "Azure Key Vault name (Relevant only for Azure targets)")]
    azure_kv_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the External Secrets Manager")]
    description: Option<String>,
    #[schemars(description = "GCP Project ID (Relevant only for GCP targets)")]
    gcp_project_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8s namespace (Relevant to Kubernetes targets)")]
    k8s_namespace: Option<String>,
    #[schemars(description = "External Secrets Manager name")]
    name: String,
    #[schemars(description = "List of the tags attached to this External Secrets Manager")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target External Secrets Manager to connect")]
    target_to_associate: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateEventForwarderInput {
    #[schemars(description = "Workstation Admin Name")]
    admin_name: Option<String>,
    #[schemars(description = "Workstation Admin password")]
    admin_pwd: Option<String>,
    #[schemars(description = "The RSA Private Key PEM formatted in base64 to use when connecting to ServiceNow with jwt authentication")]
    app_private_key_base64: Option<String>,
    #[schemars(description = "The authentication type to use when connecting to ServiceNow (user-pass / jwt)")]
    auth_type: Option<String>,
    #[schemars(description = "The client ID to use when connecting to ServiceNow with jwt authentication")]
    client_id: Option<String>,
    #[schemars(description = "The client secret to use when connecting to ServiceNow with jwt authentication")]
    client_secret: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of email addresses to send event to (relevant only for \"email\" Event Forwarder)")]
    email_to: Option<String>,
    #[schemars(description = "Event sources")]
    event_source_locations: Vec<String>,
    #[schemars(description = "Event Source type [item, target, auth_method, gateway]")]
    event_source_type: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Rate of periodic runner repetition in hours")]
    every: Option<String>,
    forwarder_type: String,
    #[schemars(description = "Workstation Host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    runner_type: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The user email to use when connecting to ServiceNow with jwt authentication")]
    user_email: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGcpTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGithubTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGitlabTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Gitlab access token")]
    gitlab_access_token: Option<String>,
    #[schemars(description = "Gitlab tls certificate (base64 encoded)")]
    gitlab_certificate: Option<String>,
    #[schemars(description = "Gitlab base url")]
    gitlab_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGkeTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGlobalSignAtlasTargetInput {
    #[schemars(description = "API Key of the GlobalSign Atlas account")]
    api_key: String,
    #[schemars(description = "API Secret of the GlobalSign Atlas account")]
    api_secret: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Mutual TLS Certificate contents of the GlobalSign Atlas account encoded in base64, either mtls-cert-file-path or mtls-cert-data-base64 must be supplied")]
    mtls_cert_data_base64: Option<String>,
    #[schemars(description = "Mutual TLS Key contents of the GlobalSign Atlas account encoded in base64, either mtls-key-file-path or mtls-data-base64 must be supplied")]
    mtls_key_data_base64: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGlobalSignTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Email of the GlobalSign GCC account contact")]
    contact_email: String,
    #[schemars(description = "First name of the GlobalSign GCC account contact")]
    contact_first_name: String,
    #[schemars(description = "Last name of the GlobalSign GCC account contact")]
    contact_last_name: String,
    #[schemars(description = "Telephone of the GlobalSign GCC account contact")]
    contact_phone: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Password of the GlobalSign GCC account")]
    password: String,
    #[schemars(description = "Profile ID of the GlobalSign GCC account")]
    profile_id: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Username of the GlobalSign GCC account")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGodaddyTargetInput {
    #[schemars(description = "Key of the api credentials to the Godaddy account")]
    api_key: String,
    #[schemars(description = "Customer ID (ShopperId) required for renewal of imported certificates")]
    customer_id: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Secret of the api credentials to the Godaddy account")]
    secret: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateGroupInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A short group alias")]
    group_alias: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Group name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A json string defining the access permission assignment for this client")]
    user_assignment: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateHashiVaultTargetInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "HashiCorp Vault API URL, e.g. https://vault-mgr01:8200")]
    hashi_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Comma-separated list of vault namespaces")]
    namespace: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Vault access token with sufficient permissions")]
    vault_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateNativeK8sTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S auth type [token/certificate]")]
    k8s_auth_type: Option<String>,
    #[schemars(description = "Content of the k8 client certificate (PEM format) in a Base64 format")]
    k8s_client_certificate: Option<String>,
    #[schemars(description = "Content of the k8 client private key (PEM format) in a Base64 format")]
    k8s_client_key: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateKeyInput {
    #[schemars(description = "Key type; options: [AES128GCM, AES256GCM, AES128SIV, AES256SIV, AES128CBC, AES256CBC, RSA1024, RSA2048, RSA3072, RSA4096]")]
    alg: String,
    #[schemars(description = "Common name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_common_name: Option<String>,
    #[schemars(description = "Country name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_country: Option<String>,
    #[schemars(description = "Digest algorithm to be used for the certificate key signing.")]
    certificate_digest_algo: Option<String>,
    #[schemars(description = "Locality for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_locality: Option<String>,
    #[schemars(description = "Organization name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_organization: Option<String>,
    #[schemars(description = "Province name for the generated certificate. Relevant only for generate-self-signed-certificate.")]
    certificate_province: Option<String>,
    #[schemars(description = "TTL in days for the generated certificate. Required only for generate-self-signed-certificate.")]
    certificate_ttl: Option<i64>,
    #[schemars(description = "The csr config data in base64 encoding")]
    conf_file_data: Option<String>,
    #[schemars(description = "The customer fragment ID that will be used to create the key (if empty, the key will be created independently of a customer fragment)")]
    customer_frg_id: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Whether to generate a self signed certificate with the key. If set, --certificate-ttl must be provided.")]
    generate_self_signed_certificate: Option<bool>,
    #[schemars(description = "Specifies the hash algorithm used for the encryption key's operations, available options: [SHA256, SHA384, SHA512]")]
    hash_algorithm: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "Key name")]
    name: String,
    #[schemars(description = "The number of fragments that the item will be split into (not includes customer fragment)")]
    split_level: Option<i64>,
    #[schemars(description = "List of the tags attached to this key")]
    tag: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateldapTargetInput {
    #[schemars(description = "Bind DN")]
    bind_dn: String,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: String,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Set Ldap server type, Options:[OpenLDAP, ActiveDirectory]. Default is OpenLDAP")]
    server_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateLinkedTargetInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of server hosts and server descriptions joined by semicolon ';' (i.e. 'server-dev.com;My Dev server,server-prod.com;My Prod server description')")]
    hosts: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "The parent Target name")]
    parent_target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Specifies the hosts type, relevant only when working without parent target")]
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateOidcAppInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "A comma separated list of allowed audiences")]
    audience: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the OIDC application (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "OIDC application name")]
    name: String,
    #[schemars(description = "A json string defining the access permission assignment for this app")]
    permission_assignment: Option<String>,
    #[schemars(description = "Set to true if the app is public (cannot keep secrets)")]
    public: Option<bool>,
    #[schemars(description = "A comma separated list of allowed redirect uris")]
    redirect_uris: Option<String>,
    #[schemars(description = "A comma separated list of allowed scopes")]
    scopes: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreatePasskeyInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Passkey type; options: [EC256, EC384, EC512]")]
    alg: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "ClassicKey name")]
    name: String,
    #[schemars(description = "Originating websites for this passkey")]
    origin_url: Option<Vec<String>>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    protection_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "For Password Management use")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreatePingTargetInput {
    #[schemars(description = "Ping Federate administrative port")]
    administrative_port: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    authorization_port: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Ping Federate privileged user password")]
    password: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    privileged_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreatePkiCertIssuerInput {
    #[schemars(description = "If set, clients can request certificates for any CN")]
    allow_any_name: Option<bool>,
    #[schemars(description = "If set, will allow copying the extra extensions from the csr file (if given)")]
    allow_copy_ext_from_csr: Option<bool>,
    #[schemars(description = "If set, clients can request certificates for subdomains of the allowed domains")]
    allow_subdomains: Option<bool>,
    #[schemars(description = "A list of the allowed domains that clients can request to be included in the certificate (in a comma-delimited list)")]
    allowed_domains: Option<String>,
    #[schemars(description = "A json string containing the allowed extra extensions for the pki cert issuer")]
    allowed_extra_extensions: Option<String>,
    #[schemars(description = "A list of the allowed CIDRs for ips that clients can request to be included in the certificate as part of the IP Subject Alternative Names (in a comma-delimited list)")]
    allowed_ip_sans: Option<String>,
    #[schemars(description = "A list of the allowed URIs that clients can request to be included in the certificate as part of the URI Subject Alternative Names (in a comma-delimited list)")]
    allowed_uri_sans: Option<String>,
    #[schemars(description = "Automatically renew certificates before expiration")]
    auto_renew: Option<bool>,
    #[schemars(description = "The name of an existing CA target to attach this PKI Certificate Issuer to, required in Public CA mode")]
    ca_target: Option<String>,
    #[schemars(description = "If set, certificates will be flagged for client auth use")]
    client_flag: Option<bool>,
    #[schemars(description = "If set, certificates will be flagged for code signing use")]
    code_signing_flag: Option<bool>,
    #[schemars(description = "A comma-separated list of countries that will be set in the issued certificate")]
    country: Option<String>,
    #[schemars(description = "Set this to allow the issuer will expose a CRL endpoint in the Gateway")]
    create_private_crl: Option<bool>,
    #[schemars(description = "Set this to enable an OCSP endpoint in the Gateway and include its URL in AIA")]
    create_private_ocsp: Option<bool>,
    #[schemars(description = "Set this to allow the cert issuer will expose a public CRL endpoint")]
    create_public_crl: Option<bool>,
    #[schemars(description = "Set this to enable a public OCSP endpoint and include its URL in AIA (served by UAM and includes account id)")]
    create_public_ocsp: Option<bool>,
    #[schemars(description = "Mark key usage as critical [true/false]")]
    critical_key_usage: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A path in which to save generated certificates")]
    destination_path: Option<String>,
    #[schemars(description = "If set, generation of wildcard certificates will be disabled.")]
    disable_wildcards: Option<bool>,
    #[schemars(description = "If set, the cert issuer will support the acme protocol")]
    enable_acme: Option<bool>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "The GW cluster URL to issue the certificate from. Required in Public CA mode, to allow CRLs on private CA, or to enable ACME")]
    gw_cluster_url: Option<String>,
    #[schemars(description = "If set, the basic constraints extension will be added to certificate")]
    is_ca: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "key-usage")]
    key_usage: Option<String>,
    #[schemars(description = "A comma-separated list of localities that will be set in the issued certificate")]
    locality: Option<String>,
    #[schemars(description = "The maximum path length for the generated certificate. -1, means unlimited")]
    max_path_len: Option<i64>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "PKI certificate issuer name")]
    name: String,
    #[schemars(description = "If set, any names are allowed for CN and SANs in the certificate and not only a valid host name")]
    not_enforce_hostnames: Option<bool>,
    #[schemars(description = "If set, clients can request certificates without a CN")]
    not_require_cn: Option<bool>,
    #[schemars(description = "OCSP NextUpdate window for OCSP responses (min 10m). Supports s,m,h,d suffix.")]
    ocsp_ttl: Option<String>,
    #[schemars(description = "A comma-separated list of organizational units (OU) that will be set in the issued certificate")]
    organizational_units: Option<String>,
    #[schemars(description = "A comma-separated list of organizations (O) that will be set in the issued certificate")]
    organizations: Option<String>,
    #[schemars(description = "A comma-separated list of postal codes that will be set in the issued certificate")]
    postal_code: Option<String>,
    #[schemars(description = "Whether to protect generated certificates from deletion")]
    protect_certificates: Option<bool>,
    #[schemars(description = "A comma-separated list of provinces that will be set in the issued certificate")]
    province: Option<String>,
    #[schemars(description = "Number of days before expiration to renew certificates")]
    scheduled_renew: Option<i64>,
    #[schemars(description = "If set, certificates will be flagged for server auth use")]
    server_flag: Option<bool>,
    #[schemars(description = "A key to sign the certificate with, required in Private CA mode")]
    signer_key_name: Option<String>,
    #[schemars(description = "A comma-separated list of street addresses that will be set in the issued certificate")]
    street_address: Option<String>,
    #[schemars(description = "List of the tags attached to this key")]
    tag: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The maximum requested Time To Live for issued certificates, in seconds. In case of Public CA, this is based on the CA target's supported maximum TTLs")]
    ttl: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateRabbitMqTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    rabbitmq_server_password: Option<String>,
    rabbitmq_server_uri: Option<String>,
    rabbitmq_server_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateRoleInput {
    #[schemars(description = "Allow this role to view analytics. Currently only 'none', 'own', 'all' values are supported, allowing associated auth methods to view reports produced by the same auth methods.")]
    analytics_access: Option<String>,
    #[schemars(description = "Allow this role to view audit logs. Currently only 'none', 'own', 'scoped' and 'all' values are supported, allowing associated auth methods to view audit logs produced by the same auth methods.")]
    audit_access: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Allow this role to view Event Center. Currently only 'none', 'scoped' and 'all' values are supported")]
    event_center_access: Option<String>,
    #[schemars(description = "Allow this role to manage Event Forwarders. Currently only 'none' and 'all' values are supported.")]
    event_forwarders_access: Option<String>,
    #[schemars(description = "Allow this role to manage the following Event Forwarders.")]
    event_forwarders_name: Option<Vec<String>>,
    #[schemars(description = "Allow this role to view gw analytics. Currently only 'none', 'scoped', 'all' values are supported, allowing associated auth methods to view reports produced by the same auth methods.")]
    gw_analytics_access: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Role name")]
    name: String,
    #[schemars(description = "Allow this role to view Reverse RBAC. Supported values: 'scoped', 'all'.")]
    reverse_rbac_access: Option<String>,
    #[schemars(description = "Allow this role to view SRA Clusters. Currently only 'none', 'scoped', 'all' values are supported.")]
    sra_reports_access: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Allow this role to view Usage Report. Currently only 'none' and 'all' values are supported.")]
    usage_reports_access: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateRotatedSecretInput {
    provider_type: Option<String>,
    #[schemars(description = "API ID to rotate (relevant only for rotator-type=api-key)")]
    api_id: Option<String>,
    #[schemars(description = "API key to rotate (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "ApplicationId (used in azure)")]
    application_id: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Aws Region (relevant only for aws)")]
    aws_region: Option<String>,
    #[schemars(description = "Secret payload to be sent with rotation request (relevant only for rotator-type=custom)")]
    custom_payload: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "The email of the gcp service account to rotate")]
    gcp_service_account_email: Option<String>,
    #[schemars(description = "The key id of the gcp service account to rotate")]
    gcp_service_account_key_id: Option<String>,
    #[schemars(description = "Create a new access key without deleting the old key from AWS for backup (relevant only for AWS) [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "Secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "The Hour of the rotation in UTC. Default rotation-hour is 14:00")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    rotator_creds_type: Option<String>,
    #[schemars(description = "Custom rotation command (relevant only for ssh target)")]
    rotator_custom_cmd: Option<String>,
    #[schemars(description = "Rotator Type")]
    rotator_type: String,
    #[schemars(description = "Rotate same password for each host from the Linked Target (relevant only for Linked Target)")]
    same_password: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users (relevant only for rdp)")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "The AWS account id (relevant only for aws)")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The db schema (relevant only for mssql or postgresql)")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable this flag to prevent simultaneous use of the same secret")]
    secure_access_disable_concurrent_connections: Option<bool>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user (relevant only for RDP Dynamic-Secret)")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username (relevant only for rdp)")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser viaAkeyless's Secure Remote Access (SRA) (relevant only for aws or azure)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA) (relevant only for aws or azure)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Deprecated: use RotatedPassword")]
    ssh_password: Option<String>,
    #[schemars(description = "Deprecated: use RotatedUser")]
    ssh_username: Option<String>,
    #[schemars(description = "The name of the storage account key to rotate [key1/key2/kerb1/kerb2] (relevat to azure-storage-account)")]
    storage_account_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "LDAP User Attribute, Default value \"cn\"")]
    user_attribute: Option<String>,
    #[schemars(description = "LDAP User Base DN")]
    user_dn: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateSalesforceTargetInput {
    #[schemars(description = "Base64 encoded PEM of the connected app private key (relevant for JWT auth only)")]
    app_private_key_data: Option<String>,
    #[schemars(description = "type of the auth flow ('jwt' / 'user-password')")]
    auth_flow: String,
    #[schemars(description = "Base64 encoded PEM cert to use when uploading a new key to Salesforce")]
    ca_cert_data: Option<String>,
    #[schemars(description = "name of the certificate in Salesforce tenant to use when uploading new key")]
    ca_cert_name: Option<String>,
    #[schemars(description = "Client ID of the oauth2 app to use for connecting to Salesforce")]
    client_id: String,
    #[schemars(description = "Client secret of the oauth2 app to use for connecting to Salesforce (required for password flow)")]
    client_secret: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "The email of the user attached to the oauth2 app used for connecting to Salesforce")]
    email: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "The password of the user attached to the oauth2 app used for connecting to Salesforce (required for user-password flow)")]
    password: Option<String>,
    #[schemars(description = "The security token of the user attached to the oauth2 app used for connecting to Salesforce  (required for user-password flow)")]
    security_token: Option<String>,
    #[schemars(description = "Url of the Salesforce tenant")]
    tenant_url: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateSecretInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Trigger an event when a secret value changed [true/false] (Relevant only for Static Secret)")]
    change_event: Option<String>,
    #[schemars(description = "For Password Management use, additional fields")]
    custom_field: Option<serde_json::Value>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Secret format [text/json/key-value] (relevant only for type 'generic')")]
    format: Option<String>,
    #[schemars(description = "For Password Management use, reflect the website context")]
    inject_url: Option<Vec<String>>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "The provided value is a multiline value (separated by '\\n')")]
    multiline_value: Option<bool>,
    #[schemars(description = "Secret name")]
    name: String,
    #[schemars(description = "For Password Management use, additional fields")]
    password: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    secure_access_gateway: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Remote Desktop Username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Static-Secret values contains SSH Credentials, either Private Key or Password [password/private-key]")]
    secure_access_ssh_creds: Option<String>,
    #[schemars(description = "Override the SSH username as indicated in SSH Certificate Issuer")]
    secure_access_ssh_user: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The secret sub type [generic/password]")]
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "For Password Management use")]
    username: Option<String>,
    #[schemars(description = "The secret value (relevant only for type 'generic')")]
    value: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateSshCertIssuerInput {
    provider_type: Option<String>,
    #[schemars(description = "Users allowed to fetch the certificate, e.g root,ubuntu")]
    allowed_users: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Signed certificates with extensions, e.g permit-port-forwarding=\\\"\\\"")]
    extensions: Option<serde_json::Value>,
    #[schemars(description = "Externally provided username [true/false]")]
    external_username: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for external-username=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "SSH certificate issuer name")]
    name: String,
    #[schemars(description = "Signed certificates with principal, e.g example_role1,example_role2")]
    principals: Option<String>,
    #[schemars(description = "Secure Access SSH control API endpoint. E.g. https://my.sra-server:9900")]
    secure_access_api: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-api")]
    secure_access_bastion_api: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-ssh")]
    secure_access_bastion_ssh: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable this flag to enforce connections only to the hosts listed in --secure-access-host")]
    secure_access_enforce_hosts_restriction: Option<bool>,
    secure_access_gateway: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Bastion's SSH server. E.g. my.sra-server:22")]
    secure_access_ssh: Option<String>,
    #[schemars(description = "SSH username to connect to target server, must be in 'Allowed Users' list")]
    secure_access_ssh_creds_user: Option<String>,
    #[schemars(description = "Deprecated. Use secure-access-use-internal-ssh-access")]
    secure_access_use_internal_bastion: Option<bool>,
    #[schemars(description = "Use internal SSH Access")]
    secure_access_use_internal_ssh_access: Option<bool>,
    #[schemars(description = "A key to sign the certificate with")]
    signer_key_name: String,
    #[schemars(description = "List of the tags attached to this key")]
    tag: Option<Vec<String>>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The requested Time To Live for the certificate, in seconds")]
    ttl: i64,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateSshTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "SSH host name")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "SSH port")]
    port: Option<String>,
    #[schemars(description = "SSH private key")]
    private_key: Option<String>,
    #[schemars(description = "SSH private key password")]
    private_key_password: Option<String>,
    #[schemars(description = "SSH password to rotate")]
    ssh_password: Option<String>,
    #[schemars(description = "SSH username")]
    ssh_username: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateTokenizerInput {
    #[schemars(description = "Alphabet to use in regexp vaultless tokenization")]
    alphabet: Option<String>,
    #[schemars(description = "The Decoding output template to use in regexp vaultless tokenization")]
    decoding_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "The Encoding output template to use in regexp vaultless tokenization")]
    encoding_template: Option<String>,
    #[schemars(description = "AES key name to use in vaultless tokenization")]
    encryption_key_name: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "Tokenizer name")]
    name: String,
    #[schemars(description = "Pattern to use in regexp vaultless tokenization")]
    pattern: Option<String>,
    #[schemars(description = "List of the tags attached to this key")]
    tag: Option<Vec<String>>,
    #[schemars(description = "Which template type this tokenizer is used for [SSN,CreditCard,USPhoneNumber,Email,Regexp]")]
    template_type: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Tokenizer type")]
    tokenizer_type: String,
    #[schemars(description = "The tweak type to use in vaultless tokenization [Supplied, Generated, Internal, Masking]")]
    tweak_type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateUscInput {
    #[schemars(description = "Azure Key Vault name (Relevant only for Azure targets)")]
    azure_kv_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the Universal Secrets Connector")]
    description: Option<String>,
    #[schemars(description = "The environments in repo-name/environment-name format, comma-separated (only relevant for: github-scope=repository-environment)")]
    environment_names: Option<String>,
    #[schemars(description = "GCP Project ID (Relevant only for GCP targets)")]
    gcp_project_id: Option<String>,
    #[schemars(description = "GCP Secret Manager regions to query for regional secrets (comma-separated, e.g., us-east1,us-west1). Max 12 regions. Required when listing with object-type=regional-secrets.")]
    gcp_sm_regions: Option<String>,
    #[schemars(description = "The scope where secrets will be created, available options: [repository, organization, repository-environment]")]
    github_scope: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8s namespace (Relevant to Kubernetes targets)")]
    k8s_namespace: Option<String>,
    #[schemars(description = "Universal Secrets Connector name")]
    name: String,
    #[schemars(description = "The organization name to create the secret in (only relevant for: github-scope=organization)")]
    organization_name: Option<String>,
    repository_access: Option<String>,
    #[schemars(description = "The repository names, comma-separated (only relevant for: github-scope=repository)")]
    repository_names: Option<String>,
    #[schemars(description = "List of the tags attached to this Universal Secrets Connector")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target Universal Secrets Connector to connect")]
    target_to_associate: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Prefix for all secrets created in AWS Secrets Manager")]
    usc_prefix: Option<String>,
    #[schemars(description = "Whether to filter the USC secret list using the specified usc-prefix [true/false]")]
    use_prefix_as_filter: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateUserEventInput {
    #[schemars(description = "List of the required capabilities options: [read, update, delete,sra_transparently_connect]. Relevant only for request-access event types")]
    capabilities: Option<Vec<String>>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    event_source: Option<String>,
    event_type: String,
    #[schemars(description = "EventItemName Event item name")]
    item_name: String,
    #[schemars(description = "EventItemType Event item type")]
    item_type: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "For how long to grant the requested access, in minutes")]
    request_access_ttl: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateWebTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The url")]
    url: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateWindowsTargetInput {
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    certificate: Option<String>,
    #[schemars(description = "Type of connection to Windows Server [credentials/parent-target]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "User domain name")]
    domain: Option<String>,
    #[schemars(description = "Server hostname")]
    hostname: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    #[schemars(description = "Privileged user password")]
    password: String,
    #[schemars(description = "Server WinRM port")]
    port: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Enable/Disable TLS for WinRM over HTTPS [true/false]")]
    use_tls: Option<String>,
    #[schemars(description = "Privileged username")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct CreateZeroSslTargetInput {
    #[schemars(description = "API Key of the ZeroSSLTarget account")]
    api_key: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapValidationEmail to use when asking ZeroSSL to send a validation email, if empty will user imap-username")]
    imap_target_email: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeactivateAcmeAccountInput {
    #[schemars(description = "The acme account id to deactivate")]
    acme_account_id: String,
    #[schemars(description = "The name of the PKI certificate issuer")]
    cert_issuer_name: String,
    #[schemars(description = "Delete the account")]
    delete_account: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DecryptInput {
    #[schemars(description = "Ciphertext to be decrypted in base64 encoded format")]
    ciphertext: Option<String>,
    #[schemars(description = "The display id of the key to use in the decryption process")]
    display_id: Option<String>,
    #[schemars(description = "The encryption context. If this was specified in the encrypt command, it must be specified here or the decryption operation will fail")]
    encryption_context: Option<serde_json::Value>,
    #[schemars(description = "The item id of the key to use in the decryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the decryption process")]
    key_name: String,
    #[schemars(description = "If specified, the output will be formatted accordingly. options: [base64]")]
    output_format: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "key version (relevant only for classic key)")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DecryptGpgInput {
    #[schemars(description = "Ciphertext to be decrypted")]
    ciphertext: String,
    #[schemars(description = "The display id of the key to use in the decryption process")]
    display_id: Option<String>,
    #[schemars(description = "Select default assumed format for the ciphertext. Currently supported options: [base64,raw]")]
    input_format: Option<String>,
    #[schemars(description = "The item id of the key to use in the decryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the decryption process")]
    key_name: String,
    #[schemars(description = "If specified, the output will be formatted accordingly. options: [base64]")]
    output_format: Option<String>,
    #[schemars(description = "Passphrase that was used to generate the key")]
    passphrase: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DecryptPkcs1Input {
    #[schemars(description = "Ciphertext to be decrypted in base64 encoded format")]
    ciphertext: String,
    #[schemars(description = "The display id of the key to use in the decryption process")]
    display_id: Option<String>,
    #[schemars(description = "The item id of the key to use in the decryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the decryption process")]
    key_name: String,
    #[schemars(description = "If specified, the output will be formatted accordingly. options: [base64]")]
    output_format: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "key version (relevant only for classic key)")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DecryptWithClassicKeyInput {
    #[schemars(description = "Ciphertext to be decrypted in base64 encoded format")]
    ciphertext: String,
    #[schemars(description = "The name of the key to use in the encryption process")]
    display_id: String,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteRoleAssociationInput {
    #[schemars(description = "The association id to be deleted")]
    assoc_id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteTargetAssociationInput {
    #[schemars(description = "The association id to be deleted")]
    assoc_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Item name")]
    name: String,
    #[schemars(description = "The target to associate")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteAuthMethodInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteAuthMethodsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Path to delete the auth methods from")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteEventForwarderInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteGwClusterInput {
    #[schemars(description = "Gateway Cluster, e.g. acc-abcd12345678/p-123456789012/defaultCluster")]
    cluster_name: String,
    #[schemars(description = "Enforce deletion")]
    force_deletion: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteGroupInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Group name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteItemInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "When delete-in-days=-1, must be set")]
    delete_immediately: Option<bool>,
    #[schemars(description = "The number of days to wait before deleting the item (relevant for keys only)")]
    delete_in_days: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Item name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The specific version you want to delete - 0=last version, -1=entire item with all versions (default)")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteItemsInput {
    #[schemars(description = "A list of items to delete, To specify multiple items use argument multiple times")]
    item: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Path to delete the items from")]
    path: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteRoleInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Role name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteRoleRuleInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The path the rule refers to")]
    path: String,
    #[schemars(description = "The role name to be updated")]
    role_name: String,
    #[schemars(description = "item-rule, role-rule, auth-method-rule, search-rule, reports-rule, gw-reports-rule or sra-reports-rule")]
    rule_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteRolesInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Path to delete the auth methods from")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteTargetInput {
    #[schemars(description = "Enforce deletion")]
    force_deletion: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Target version")]
    target_version: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteTargetsInput {
    #[schemars(description = "Enforce deletion")]
    force_deletion: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Path to delete the targets from")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeriveKeyInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Kdf algorithm")]
    alg: String,
    #[schemars(description = "HashFunction the hash function to use (relevant for pbkdf2)")]
    hash_function: Option<String>,
    #[schemars(description = "IterationCount the number of iterations")]
    iter: i64,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "KeyLength the byte length of the generated key")]
    key_len: i64,
    #[schemars(description = "MemorySizeInKb the memory paramter in kb (relevant for argon2id)")]
    mem: Option<i64>,
    #[schemars(description = "Static Secret full name")]
    name: String,
    #[schemars(description = "Parallelism the number of threads to use (relevant for argon2id)")]
    parallelism: Option<i64>,
    #[schemars(description = "Salt Base64 encoded salt value. If not provided, the salt will be generated as part of the operation. The salt should be securely-generated random bytes, minimum 64 bits, 128 bits is recommended")]
    salt: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DescribeItemInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Indicate if the item should return with ztb cluster details (url, etc)")]
    bastion_details: Option<bool>,
    #[schemars(description = "The certificate will be displayed in DER format")]
    der_certificate_format: Option<bool>,
    #[schemars(description = "The display id of the item")]
    display_id: Option<String>,
    #[schemars(description = "Indicate if the item should return with clusters details (url, etc)")]
    gateway_details: Option<bool>,
    #[schemars(description = "Include all item custom fields details")]
    item_custom_fields_details: Option<bool>,
    #[schemars(description = "Item id of the item")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Item name")]
    name: String,
    #[schemars(description = "Include all associated services details")]
    services_details: Option<bool>,
    #[schemars(description = "Include all item versions in reply")]
    show_versions: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DescribePermissionsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Path to an object")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Type of object (item, am, role, target)")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DescribeAssocInput {
    #[schemars(description = "The association id")]
    assoc_id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DescribeSubClaimsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DetokenizeInput {
    #[schemars(description = "Data to be decrypted")]
    ciphertext: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The name of the tokenizer to use in the decryption process")]
    tokenizer_name: String,
    #[schemars(description = "Base64 encoded tweak for vaultless encryption")]
    tweak: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateArtifactoryInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: Option<String>,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: Option<String>,
    #[schemars(description = "Token Audience")]
    artifactory_token_audience: String,
    #[schemars(description = "Token Scope")]
    artifactory_token_scope: String,
    #[schemars(description = "Base URL")]
    base_url: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateAwsInput {
    access_mode: Option<String>,
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Access Key ID")]
    aws_access_key_id: Option<String>,
    #[schemars(description = "Secret Access Key")]
    aws_access_secret_key: Option<String>,
    #[schemars(description = "The AWS External ID associated with the AWS role (relevant only for assume_role mode)")]
    aws_external_id: Option<String>,
    #[schemars(description = "AWS Role ARNs to be used in the Assume Role operation (relevant only for assume_role mode)")]
    aws_role_arns: Option<String>,
    #[schemars(description = "AWS User console access")]
    aws_user_console_access: Option<bool>,
    #[schemars(description = "AWS User groups")]
    aws_user_groups: Option<String>,
    #[schemars(description = "AWS User policies")]
    aws_user_policies: Option<String>,
    #[schemars(description = "Enable AWS User programmatic access")]
    aws_user_programmatic_access: Option<bool>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Region")]
    region: Option<String>,
    #[schemars(description = "The AWS account id")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "String of Key value session tags comma separated, relevant only for Assumed Role")]
    session_tags: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "String of transitive tag keys space separated, relevant only for Assumed Role")]
    transitive_tag_keys: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateAzureInput {
    #[schemars(description = "Azure App Object Id")]
    app_obj_id: Option<String>,
    #[schemars(description = "Azure AD administrative unit (relevant only when azure-user-portal-access=true)")]
    azure_administrative_unit: Option<String>,
    #[schemars(description = "Azure Client ID")]
    azure_client_id: Option<String>,
    #[schemars(description = "Azure Client Secret")]
    azure_client_secret: Option<String>,
    #[schemars(description = "Azure Tenant ID")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "FixedUserClaimKeyname")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Fixed user")]
    fixed_user_only: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic secret encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Group Object Id")]
    user_group_obj_id: Option<String>,
    #[schemars(description = "Azure User portal access")]
    user_portal_access: Option<bool>,
    #[schemars(description = "User Principal Name")]
    user_principal_name: Option<String>,
    #[schemars(description = "Azure User programmatic access")]
    user_programmatic_access: Option<bool>,
    #[schemars(description = "User Role Template Id")]
    user_role_template_id: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateCassandraInput {
    #[schemars(description = "Cassandra creation statements")]
    cassandra_creation_statements: Option<String>,
    #[schemars(description = "Cassandra hosts IP or addresses, comma separated")]
    cassandra_hosts: Option<String>,
    #[schemars(description = "Cassandra superuser password")]
    cassandra_password: Option<String>,
    #[schemars(description = "Cassandra port")]
    cassandra_port: Option<String>,
    #[schemars(description = "Cassandra superuser username")]
    cassandra_username: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateCustomInput {
    #[schemars(description = "Define rotation interval in days")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "URL of an endpoint that implements /sync/create method, for example https://webhook.example.com/sync/create")]
    create_sync_url: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Should admin credentials be rotated")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Secret payload to be sent with each create/revoke webhook request")]
    payload: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "URL of an endpoint that implements /sync/revoke method, for example https://webhook.example.com/sync/revoke")]
    revoke_sync_url: String,
    #[schemars(description = "URL of an endpoint that implements /sync/rotate method, for example https://webhook.example.com/sync/rotate")]
    rotate_sync_url: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Maximum allowed time in seconds for the webhook to return the results")]
    timeout_sec: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateDockerhubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "DockerhubPassword is either the user's password access token to manage the repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Access token scopes list (comma-separated) to give the dynamic secret valid options are in \"repo:admin\", \"repo:write\", \"repo:read\", \"repo:public_read\"")]
    dockerhub_token_scopes: Option<String>,
    #[schemars(description = "DockerhubUsername is the name of the user in dockerhub")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateEksInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: Option<String>,
    #[schemars(description = "IAM assume role")]
    eks_assume_role: Option<String>,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: Option<String>,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: Option<String>,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: Option<String>,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateGcpInput {
    access_type: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (Relevant only when --access-type=external)")]
    fixed_user_claim_keyname: Option<String>,
    gcp_cred_type: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Service account key algorithm, e.g. KEY_ALG_RSA_1024 (Relevant only when --access-type=sa and --gcp-cred-type=key)")]
    gcp_key_algo: Option<String>,
    #[schemars(description = "GCP Project ID override for dynamic secret operations")]
    gcp_project_id: Option<String>,
    #[schemars(description = "The email of the fixed service account to generate keys or tokens for (Relevant only when --access-type=sa and --service-account-type=fixed)")]
    gcp_sa_email: Option<String>,
    #[schemars(description = "Access token scopes list, e.g. scope1,scope2 (Relevant only when --access-type=sa; required when --gcp-cred-type=token)")]
    gcp_token_scopes: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Role binding definitions in JSON format (Relevant only when --access-type=sa and --service-account-type=dynamic)")]
    role_binding: Option<String>,
    #[schemars(description = "Comma-separated list of GCP roles to assign to the user (Relevant only when --access-type=external)")]
    role_names: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "The type of the GCP service account. Options [fixed, dynamic] (Relevant only when --access-type=sa)")]
    service_account_type: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateGithubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "GitHub application installation id")]
    installation_id: Option<i64>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub organization name")]
    installation_organization: Option<String>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub repository '<owner>/<repo-name>'")]
    installation_repository: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Optional - installation token's allowed permissions")]
    token_permissions: Option<Vec<String>>,
    #[schemars(description = "Optional - installation token's allowed repositories")]
    token_repositories: Option<Vec<String>>,
    #[schemars(description = "Token TTL")]
    token_ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateGitlabInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Gitlab access token")]
    gitlab_access_token: Option<String>,
    #[schemars(description = "Gitlab access token type [project,group]")]
    gitlab_access_type: String,
    #[schemars(description = "Gitlab tls certificate (base64 encoded)")]
    gitlab_certificate: Option<String>,
    #[schemars(description = "Gitlab role")]
    gitlab_role: Option<String>,
    #[schemars(description = "Comma-separated list of access token scopes to grant")]
    gitlab_token_scopes: String,
    #[schemars(description = "Gitlab base url")]
    gitlab_url: Option<String>,
    #[schemars(description = "Gitlab group name, required for access-type=group")]
    group_name: Option<String>,
    #[schemars(description = "Gitlab project name, required for access-type=project")]
    installation_organization: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Access Token TTL")]
    ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateGkeInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateGoogleWorkspaceInput {
    access_mode: String,
    #[schemars(description = "Admin user email")]
    admin_email: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "A group email, relevant only for group access-mode")]
    group_email: Option<String>,
    group_role: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Name of the admin role to assign to the user, relevant only for role access-mode")]
    role_name: Option<String>,
    role_scope: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Name of existing target to use in dynamic secret creation")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateHanaDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "HanaDb Name")]
    hana_dbname: Option<String>,
    #[schemars(description = "HanaDb Creation statements")]
    hanadb_create_statements: Option<String>,
    #[schemars(description = "HanaDb Host")]
    hanadb_host: Option<String>,
    #[schemars(description = "HanaDb Password")]
    hanadb_password: Option<String>,
    #[schemars(description = "HanaDb Port")]
    hanadb_port: Option<String>,
    #[schemars(description = "HanaDb Revocation statements")]
    hanadb_revocation_statements: Option<String>,
    #[schemars(description = "HanaDb Username")]
    hanadb_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateK8sInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Comma-separated list of allowed K8S namespaces for the generated ServiceAccount (relevant only for k8s-service-account-type=dynamic)")]
    k8s_allowed_namespaces: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "K8S Namespace where the ServiceAccount exists.")]
    k8s_namespace: Option<String>,
    #[schemars(description = "The pre-existing Role or ClusterRole name to bind the generated ServiceAccount to (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_name: Option<String>,
    #[schemars(description = "Specifies the type of the pre-existing K8S role [Role, ClusterRole] (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_type: Option<String>,
    #[schemars(description = "Content of the yaml in a Base64 format.")]
    k8s_rolebinding_yaml_data: Option<String>,
    #[schemars(description = "Path to yaml file that contains definitions of K8S role and role binding (relevant only for k8s-service-account-type=dynamic)")]
    k8s_rolebinding_yaml_def: Option<String>,
    #[schemars(description = "K8S ServiceAccount to extract token from.")]
    k8s_service_account: Option<String>,
    #[schemars(description = "K8S ServiceAccount type [fixed, dynamic].")]
    k8s_service_account_type: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The K8s dashboard url")]
    secure_access_dashboard_url: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateLdapInput {
    provider_type: Option<String>,
    #[schemars(description = "Bind DN")]
    bind_dn: Option<String>,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Externally provided username [true/false]")]
    external_username: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for external-username=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Group DN which the temporary user should be added")]
    group_dn: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Attribute")]
    user_attribute: Option<String>,
    #[schemars(description = "User DN")]
    user_dn: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateMongoDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB custom data")]
    mongodb_custom_data: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server host and port")]
    mongodb_host_port: Option<String>,
    #[schemars(description = "MongoDB Name")]
    mongodb_name: Option<String>,
    #[schemars(description = "MongoDB server password. You will prompted to provide a password if it will not appear in CLI parameters")]
    mongodb_password: Option<String>,
    #[schemars(description = "MongoDB Roles")]
    mongodb_roles: Option<String>,
    #[schemars(description = "MongoDB Scopes (Atlas only)")]
    mongodb_scopes: Option<String>,
    #[schemars(description = "MongoDB server URI")]
    mongodb_server_uri: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "MongoDB server username")]
    mongodb_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Encrypt producer with following key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateMsSqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CSV of allowed DB names for runtime selection when getting the secret value. Empty => use target DB only; \"*\" => any DB allowed; One or more names => user must choose from this list")]
    mssql_allowed_db_names: Option<String>,
    #[schemars(description = "MSSQL Creation statements")]
    mssql_create_statements: Option<String>,
    #[schemars(description = "MSSQL Name")]
    mssql_dbname: Option<String>,
    #[schemars(description = "MSSQL Host")]
    mssql_host: Option<String>,
    #[schemars(description = "MSSQL Password")]
    mssql_password: Option<String>,
    #[schemars(description = "MSSQL Port")]
    mssql_port: Option<String>,
    #[schemars(description = "MSSQL Revocation statements")]
    mssql_revocation_statements: Option<String>,
    #[schemars(description = "MSSQL Username")]
    mssql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateMySqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MySQL DB Name")]
    mysql_dbname: Option<String>,
    #[schemars(description = "MySQL Host")]
    mysql_host: Option<String>,
    #[schemars(description = "MySQL Password")]
    mysql_password: Option<String>,
    #[schemars(description = "MySQL Port")]
    mysql_port: Option<String>,
    #[schemars(description = "MySQL Revocation statements")]
    mysql_revocation_statements: Option<String>,
    #[schemars(description = "MySQL Creation statements")]
    mysql_screation_statements: Option<String>,
    #[schemars(description = "MySQL Username")]
    mysql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateOpenAiInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Project ID")]
    project_id: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Name of existing target to use in producer creation")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateOracleDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Oracle Host")]
    oracle_host: Option<String>,
    #[schemars(description = "Oracle Password")]
    oracle_password: Option<String>,
    #[schemars(description = "Oracle Port")]
    oracle_port: Option<String>,
    #[schemars(description = "Oracle Revocation statements")]
    oracle_revocation_statements: Option<String>,
    #[schemars(description = "Oracle Creation statements")]
    oracle_screation_statements: Option<String>,
    #[schemars(description = "Oracle DB Name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Username")]
    oracle_username: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreatePingInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Ping Federate administrative port")]
    ping_administrative_port: Option<String>,
    #[schemars(description = "Set a specific Access Token Management (ATM) instance for the created OAuth Client by providing the ATM Id. If no explicit value is given, the default pingfederate server ATM will be set.")]
    ping_atm_id: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    ping_authorization_port: Option<String>,
    #[schemars(description = "The subject DN of the client certificate. If no explicit value is given, the producer will create CA certificate and matched client certificate and return it as value. Used in conjunction with ping-issuer-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_cert_subject_dn: Option<String>,
    #[schemars(description = "OAuth Client Authentication Type [CLIENT_SECRET, PRIVATE_KEY_JWT, CLIENT_TLS_CERTIFICATE]")]
    ping_client_authentication_type: Option<String>,
    #[schemars(description = "Determines whether PingFederate requires a unique signed JWT from the client for each action (relevant for PRIVATE_KEY_JWT authentication method) [true/false]")]
    ping_enforce_replay_prevention: Option<String>,
    #[schemars(description = "List of OAuth client grant types [IMPLICIT, AUTHORIZATION_CODE, CLIENT_CREDENTIALS, TOKEN_EXCHANGE, REFRESH_TOKEN, ASSERTION_GRANTS, PASSWORD, RESOURCE_OWNER_CREDENTIALS]. If no explicit value is given, AUTHORIZATION_CODE will be selected as default.")]
    ping_grant_types: Option<Vec<String>>,
    #[schemars(description = "Issuer DN of trusted CA certificate that imported into Ping Federate server. You may select \\\"Trust Any\\\" to trust all the existing issuers in Ping Federate server. Used in conjunction with ping-cert-subject-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_issuer_dn: Option<String>,
    #[schemars(description = "Base64-encoded JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT (Sign Algo: RS256) and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks: Option<String>,
    #[schemars(description = "The URL of the JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user password")]
    ping_password: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    ping_privileged_user: Option<String>,
    #[schemars(description = "List of URIs to which the OAuth authorization server may redirect the resource owner's user agent after authorization is obtained. At least one redirection URI is required for the AUTHORIZATION_CODE and IMPLICIT grant types.")]
    ping_redirect_uris: Option<Vec<String>>,
    #[schemars(description = "Limit the OAuth client to specific scopes list")]
    ping_restricted_scopes: Option<Vec<String>>,
    #[schemars(description = "The signing algorithm that the client must use to sign its request objects [RS256,RS384,RS512,ES256,ES384,ES512,PS256,PS384,PS512] If no explicit value is given, the client can use any of the supported signing algorithms (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_signing_algo: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The time from dynamic secret creation to expiration.")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreatePostgreSqlInput {
    #[schemars(description = "PostgreSQL Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "PostgreSQL DB Name")]
    postgresql_db_name: Option<String>,
    #[schemars(description = "PostgreSQL Host")]
    postgresql_host: Option<String>,
    #[schemars(description = "PostgreSQL Password")]
    postgresql_password: Option<String>,
    #[schemars(description = "PostgreSQL Port")]
    postgresql_port: Option<String>,
    #[schemars(description = "PostgreSQL Username")]
    postgresql_username: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "PostgreSQL Revocation statements")]
    revocation_statement: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateRabbitMqInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RabbitMQ Admin password")]
    rabbitmq_admin_pwd: Option<String>,
    #[schemars(description = "RabbitMQ Admin User")]
    rabbitmq_admin_user: Option<String>,
    #[schemars(description = "Server URI")]
    rabbitmq_server_uri: Option<String>,
    #[schemars(description = "User configuration permission")]
    rabbitmq_user_conf_permission: Option<String>,
    #[schemars(description = "User read permission")]
    rabbitmq_user_read_permission: Option<String>,
    #[schemars(description = "User Tags")]
    rabbitmq_user_tags: Option<String>,
    #[schemars(description = "User Virtual Host")]
    rabbitmq_user_vhost: Option<String>,
    #[schemars(description = "User write permission")]
    rabbitmq_user_write_permission: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateRdpInput {
    #[schemars(description = "AllowUserExtendSession")]
    allow_user_extend_session: Option<i64>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for fixed-user-only=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Allow access using externally (IdP) provided username [true/false]")]
    fixed_user_only: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RDP Admin Name")]
    rdp_admin_name: Option<String>,
    #[schemars(description = "RDP Admin password")]
    rdp_admin_pwd: Option<String>,
    #[schemars(description = "Hostname")]
    rdp_host_name: Option<String>,
    #[schemars(description = "Port")]
    rdp_host_port: Option<String>,
    #[schemars(description = "Groups")]
    rdp_user_groups: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "WarnBeforeUserExpiration")]
    warn_user_before_expiration: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateRedisInput {
    #[schemars(description = "A JSON array list of redis ACL rules to attach to the created user. For available rules see the ACL CAT command https://redis.io/commands/acl-cat By default the user will have permissions to read all keys '[\"~*\", \"+@read\"]'")]
    acl_rules: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Redis Host")]
    host: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Redis Password")]
    password: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Redis Port")]
    port: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Redis Username")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateRedshiftInput {
    #[schemars(description = "Redshift Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "Redshift DB Name")]
    redshift_db_name: Option<String>,
    #[schemars(description = "Redshift Host")]
    redshift_host: Option<String>,
    #[schemars(description = "Redshift Password")]
    redshift_password: Option<String>,
    #[schemars(description = "Redshift Port")]
    redshift_port: Option<String>,
    #[schemars(description = "Redshift Username")]
    redshift_username: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateSnowflakeInput {
    #[schemars(description = "Account name")]
    account: Option<String>,
    #[schemars(description = "Database Password")]
    account_password: Option<String>,
    #[schemars(description = "Database Username")]
    account_username: Option<String>,
    #[schemars(description = "The authentication mode for the temporary user [password/key]")]
    auth_mode: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Database name")]
    db_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    key_algo: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    private_key_passphrase: Option<String>,
    #[schemars(description = "User role")]
    role: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Warehouse name")]
    warehouse: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretCreateVenafiInput {
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Allow subdomains")]
    allow_subdomains: Option<bool>,
    #[schemars(description = "Allowed domains")]
    allowed_domains: Option<Vec<String>>,
    #[schemars(description = "Auto generated folder")]
    auto_generated_folder: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Root first in chain")]
    root_first_in_chain: Option<bool>,
    #[schemars(description = "Use Akeyless PKI issuer or Venafi issuer")]
    sign_using_akeyless_pki: Option<bool>,
    #[schemars(description = "Signer key name")]
    signer_key_name: Option<String>,
    #[schemars(description = "Store private key")]
    store_private_key: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL in time.Duration format (2160h / 129600m / etc...). When using sign-using-akeyless-pki certificates created will have this validity period, otherwise the user-ttl is taken from the Validity Period field of the Zone's' Issuing Template. When using cert-manager it is advised to have a TTL of above 60 days (1440h). For more information - https://cert-manager.io/docs/usage/certificate/")]
    user_ttl: Option<String>,
    #[schemars(description = "Venafi Access Token to use to access the TPP environment (Relevant when using TPP)")]
    venafi_access_token: Option<String>,
    #[schemars(description = "Venafi API key")]
    venafi_api_key: Option<String>,
    #[schemars(description = "Venafi Baseurl")]
    venafi_baseurl: Option<String>,
    #[schemars(description = "Venafi Client ID that was used when the access token was generated")]
    venafi_client_id: Option<String>,
    #[schemars(description = "Venafi Refresh Token to use when the Access Token is expired (Relevant when using TPP)")]
    venafi_refresh_token: Option<String>,
    #[schemars(description = "Venafi using TPP")]
    venafi_use_tpp: Option<bool>,
    #[schemars(description = "Venafi Zone")]
    venafi_zone: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretDeleteInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretGetInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretGetValueInput {
    #[schemars(description = "Optional arguments as key=value pairs or JSON strings, e.g - \\\"--args=csr=base64_encoded_csr --args=common_name=bar\\\" or args='{\\\"csr\\\":\\\"base64_encoded_csr\\\"}. It is possible to combine both formats.'")]
    args: Option<Vec<String>>,
    #[schemars(description = "DBName: Optional override DB name (works only if DS allows it. only relevant for MSSQL)")]
    dbname: Option<String>,
    #[schemars(description = "Host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Target Name")]
    target: Option<String>,
    #[schemars(description = "Timeout in seconds")]
    timeout: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretListInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretTmpCredsGetInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretTmpCredsDeleteInput {
    #[schemars(description = "Host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Revoke All Temp Creds")]
    revoke_all: Option<bool>,
    #[schemars(description = "Soft Delete")]
    soft_delete: Option<bool>,
    #[schemars(description = "Tmp Creds ID")]
    tmp_creds_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretTmpCredsUpdateInput {
    #[schemars(description = "Host")]
    host: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "New TTL in Minutes")]
    new_ttl_min: i64,
    #[schemars(description = "Tmp Creds ID")]
    tmp_creds_id: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateArtifactoryInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: Option<String>,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: Option<String>,
    #[schemars(description = "Token Audience")]
    artifactory_token_audience: String,
    #[schemars(description = "Token Scope")]
    artifactory_token_scope: String,
    #[schemars(description = "Base URL")]
    base_url: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateAwsInput {
    access_mode: Option<String>,
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Access Key ID")]
    aws_access_key_id: Option<String>,
    #[schemars(description = "Secret Access Key")]
    aws_access_secret_key: Option<String>,
    #[schemars(description = "The AWS External ID associated with the AWS role (relevant only for assume_role mode)")]
    aws_external_id: Option<String>,
    #[schemars(description = "AWS Role ARNs to be used in the Assume Role operation (relevant only for assume_role mode)")]
    aws_role_arns: Option<String>,
    #[schemars(description = "AWS User console access")]
    aws_user_console_access: Option<bool>,
    #[schemars(description = "AWS User groups")]
    aws_user_groups: Option<String>,
    #[schemars(description = "AWS User policies")]
    aws_user_policies: Option<String>,
    #[schemars(description = "Enable AWS User programmatic access")]
    aws_user_programmatic_access: Option<bool>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Region")]
    region: Option<String>,
    #[schemars(description = "The AWS account id")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "String of Key value session tags comma separated, relevant only for Assumed Role")]
    session_tags: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "String of transitive tag keys space separated, relevant only for Assumed Role")]
    transitive_tag_keys: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateAzureInput {
    #[schemars(description = "Azure App Object Id")]
    app_obj_id: Option<String>,
    #[schemars(description = "Azure AD administrative unit (relevant only when azure-user-portal-access=true)")]
    azure_administrative_unit: Option<String>,
    #[schemars(description = "Azure Client ID")]
    azure_client_id: Option<String>,
    #[schemars(description = "Azure Client Secret")]
    azure_client_secret: Option<String>,
    #[schemars(description = "Azure Tenant ID")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "FixedUserClaimKeyname")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Fixed user")]
    fixed_user_only: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic secret encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Group Object Id")]
    user_group_obj_id: Option<String>,
    #[schemars(description = "Azure User portal access")]
    user_portal_access: Option<bool>,
    #[schemars(description = "User Principal Name")]
    user_principal_name: Option<String>,
    #[schemars(description = "Azure User programmatic access")]
    user_programmatic_access: Option<bool>,
    #[schemars(description = "User Role Template Id")]
    user_role_template_id: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateCassandraInput {
    #[schemars(description = "Cassandra creation statements")]
    cassandra_creation_statements: Option<String>,
    #[schemars(description = "Cassandra hosts IP or addresses, comma separated")]
    cassandra_hosts: Option<String>,
    #[schemars(description = "Cassandra superuser password")]
    cassandra_password: Option<String>,
    #[schemars(description = "Cassandra port")]
    cassandra_port: Option<String>,
    #[schemars(description = "Cassandra superuser username")]
    cassandra_username: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateCustomInput {
    #[schemars(description = "Define rotation interval in days")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "URL of an endpoint that implements /sync/create method, for example https://webhook.example.com/sync/create")]
    create_sync_url: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Should admin credentials be rotated")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Secret payload to be sent with each create/revoke webhook request")]
    payload: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "URL of an endpoint that implements /sync/revoke method, for example https://webhook.example.com/sync/revoke")]
    revoke_sync_url: String,
    #[schemars(description = "URL of an endpoint that implements /sync/rotate method, for example https://webhook.example.com/sync/rotate")]
    rotate_sync_url: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Maximum allowed time in seconds for the webhook to return the results")]
    timeout_sec: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateDockerhubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "DockerhubPassword is either the user's password access token to manage the repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Access token scopes list (comma-separated) to give the dynamic secret valid options are in \"repo:admin\", \"repo:write\", \"repo:read\", \"repo:public_read\"")]
    dockerhub_token_scopes: Option<String>,
    #[schemars(description = "DockerhubUsername is the name of the user in dockerhub")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateEksInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: Option<String>,
    #[schemars(description = "IAM assume role")]
    eks_assume_role: Option<String>,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: Option<String>,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: Option<String>,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: Option<String>,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateGcpInput {
    access_type: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (Relevant only when --access-type=external)")]
    fixed_user_claim_keyname: Option<String>,
    gcp_cred_type: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Service account key algorithm, e.g. KEY_ALG_RSA_1024 (Relevant only when --access-type=sa and --gcp-cred-type=key)")]
    gcp_key_algo: Option<String>,
    #[schemars(description = "GCP Project ID override for dynamic secret operations")]
    gcp_project_id: Option<String>,
    #[schemars(description = "The email of the fixed service account to generate keys or tokens for (Relevant only when --access-type=sa and --service-account-type=fixed)")]
    gcp_sa_email: Option<String>,
    #[schemars(description = "Access token scopes list, e.g. scope1,scope2 (Relevant only when --access-type=sa; required when --gcp-cred-type=token)")]
    gcp_token_scopes: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Role binding definitions in JSON format (Relevant only when --access-type=sa and --service-account-type=dynamic)")]
    role_binding: Option<String>,
    #[schemars(description = "Comma-separated list of GCP roles to assign to the user (Relevant only when --access-type=external)")]
    role_names: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "The type of the GCP service account. Options [fixed, dynamic] (Relevant only when --access-type=sa)")]
    service_account_type: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateGithubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "GitHub application installation id")]
    installation_id: Option<i64>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub organization name")]
    installation_organization: Option<String>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub repository '<owner>/<repo-name>'")]
    installation_repository: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Optional - installation token's allowed permissions")]
    token_permissions: Option<Vec<String>>,
    #[schemars(description = "Optional - installation token's allowed repositories")]
    token_repositories: Option<Vec<String>>,
    #[schemars(description = "Token TTL")]
    token_ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateGitlabInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Gitlab access token")]
    gitlab_access_token: Option<String>,
    #[schemars(description = "Gitlab access token type [project,group]")]
    gitlab_access_type: String,
    #[schemars(description = "Gitlab tls certificate (base64 encoded)")]
    gitlab_certificate: Option<String>,
    #[schemars(description = "Gitlab role")]
    gitlab_role: Option<String>,
    #[schemars(description = "Comma-separated list of access token scopes to grant")]
    gitlab_token_scopes: String,
    #[schemars(description = "Gitlab base url")]
    gitlab_url: Option<String>,
    #[schemars(description = "Gitlab group name, required for access-type=group")]
    group_name: Option<String>,
    #[schemars(description = "Gitlab project name, required for access-type=project")]
    installation_organization: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Access Token TTL")]
    ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateGkeInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateGoogleWorkspaceInput {
    access_mode: String,
    #[schemars(description = "Admin user email")]
    admin_email: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "A group email, relevant only for group access-mode")]
    group_email: Option<String>,
    group_role: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Name of the admin role to assign to the user, relevant only for role access-mode")]
    role_name: Option<String>,
    role_scope: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Name of existing target to use in dynamic secret creation")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateHanaDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "HanaDb Name")]
    hana_dbname: Option<String>,
    #[schemars(description = "HanaDb Creation statements")]
    hanadb_create_statements: Option<String>,
    #[schemars(description = "HanaDb Host")]
    hanadb_host: Option<String>,
    #[schemars(description = "HanaDb Password")]
    hanadb_password: Option<String>,
    #[schemars(description = "HanaDb Port")]
    hanadb_port: Option<String>,
    #[schemars(description = "HanaDb Revocation statements")]
    hanadb_revocation_statements: Option<String>,
    #[schemars(description = "HanaDb Username")]
    hanadb_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateK8sInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Comma-separated list of allowed K8S namespaces for the generated ServiceAccount (relevant only for k8s-service-account-type=dynamic)")]
    k8s_allowed_namespaces: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "K8S Namespace where the ServiceAccount exists.")]
    k8s_namespace: Option<String>,
    #[schemars(description = "The pre-existing Role or ClusterRole name to bind the generated ServiceAccount to (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_name: Option<String>,
    #[schemars(description = "Specifies the type of the pre-existing K8S role [Role, ClusterRole] (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_type: Option<String>,
    #[schemars(description = "Content of the yaml in a Base64 format.")]
    k8s_rolebinding_yaml_data: Option<String>,
    #[schemars(description = "Path to yaml file that contains definitions of K8S role and role binding (relevant only for k8s-service-account-type=dynamic)")]
    k8s_rolebinding_yaml_def: Option<String>,
    #[schemars(description = "K8S ServiceAccount to extract token from.")]
    k8s_service_account: Option<String>,
    #[schemars(description = "K8S ServiceAccount type [fixed, dynamic].")]
    k8s_service_account_type: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The K8s dashboard url")]
    secure_access_dashboard_url: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateLdapInput {
    provider_type: Option<String>,
    #[schemars(description = "Bind DN")]
    bind_dn: Option<String>,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Externally provided username [true/false]")]
    external_username: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for external-username=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Group DN which the temporary user should be added")]
    group_dn: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Attribute")]
    user_attribute: Option<String>,
    #[schemars(description = "User DN")]
    user_dn: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateMongoDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB custom data")]
    mongodb_custom_data: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server host and port")]
    mongodb_host_port: Option<String>,
    #[schemars(description = "MongoDB Name")]
    mongodb_name: Option<String>,
    #[schemars(description = "MongoDB server password. You will prompted to provide a password if it will not appear in CLI parameters")]
    mongodb_password: Option<String>,
    #[schemars(description = "MongoDB Roles")]
    mongodb_roles: Option<String>,
    #[schemars(description = "MongoDB Scopes (Atlas only)")]
    mongodb_scopes: Option<String>,
    #[schemars(description = "MongoDB server URI")]
    mongodb_server_uri: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "MongoDB server username")]
    mongodb_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Encrypt producer with following key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateMsSqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CSV of allowed DB names for runtime selection when getting the secret value. Empty => use target DB only; \"*\" => any DB allowed; One or more names => user must choose from this list")]
    mssql_allowed_db_names: Option<String>,
    #[schemars(description = "MSSQL Creation statements")]
    mssql_create_statements: Option<String>,
    #[schemars(description = "MSSQL Name")]
    mssql_dbname: Option<String>,
    #[schemars(description = "MSSQL Host")]
    mssql_host: Option<String>,
    #[schemars(description = "MSSQL Password")]
    mssql_password: Option<String>,
    #[schemars(description = "MSSQL Port")]
    mssql_port: Option<String>,
    #[schemars(description = "MSSQL Revocation statements")]
    mssql_revocation_statements: Option<String>,
    #[schemars(description = "MSSQL Username")]
    mssql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateMySqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MySQL DB Name")]
    mysql_dbname: Option<String>,
    #[schemars(description = "MySQL Host")]
    mysql_host: Option<String>,
    #[schemars(description = "MySQL Password")]
    mysql_password: Option<String>,
    #[schemars(description = "MySQL Port")]
    mysql_port: Option<String>,
    #[schemars(description = "MySQL Revocation statements")]
    mysql_revocation_statements: Option<String>,
    #[schemars(description = "MySQL Creation statements")]
    mysql_screation_statements: Option<String>,
    #[schemars(description = "MySQL Username")]
    mysql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateOpenAiInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Project ID")]
    project_id: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Name of existing target to use in producer creation")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateOracleDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Oracle Host")]
    oracle_host: Option<String>,
    #[schemars(description = "Oracle Password")]
    oracle_password: Option<String>,
    #[schemars(description = "Oracle Port")]
    oracle_port: Option<String>,
    #[schemars(description = "Oracle Revocation statements")]
    oracle_revocation_statements: Option<String>,
    #[schemars(description = "Oracle Creation statements")]
    oracle_screation_statements: Option<String>,
    #[schemars(description = "Oracle DB Name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Username")]
    oracle_username: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdatePingInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Ping Federate administrative port")]
    ping_administrative_port: Option<String>,
    #[schemars(description = "Set a specific Access Token Management (ATM) instance for the created OAuth Client by providing the ATM Id. If no explicit value is given, the default pingfederate server ATM will be set.")]
    ping_atm_id: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    ping_authorization_port: Option<String>,
    #[schemars(description = "The subject DN of the client certificate. If no explicit value is given, the producer will create CA certificate and matched client certificate and return it as value. Used in conjunction with ping-issuer-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_cert_subject_dn: Option<String>,
    #[schemars(description = "OAuth Client Authentication Type [CLIENT_SECRET, PRIVATE_KEY_JWT, CLIENT_TLS_CERTIFICATE]")]
    ping_client_authentication_type: Option<String>,
    #[schemars(description = "Determines whether PingFederate requires a unique signed JWT from the client for each action (relevant for PRIVATE_KEY_JWT authentication method) [true/false]")]
    ping_enforce_replay_prevention: Option<String>,
    #[schemars(description = "List of OAuth client grant types [IMPLICIT, AUTHORIZATION_CODE, CLIENT_CREDENTIALS, TOKEN_EXCHANGE, REFRESH_TOKEN, ASSERTION_GRANTS, PASSWORD, RESOURCE_OWNER_CREDENTIALS]. If no explicit value is given, AUTHORIZATION_CODE will be selected as default.")]
    ping_grant_types: Option<Vec<String>>,
    #[schemars(description = "Issuer DN of trusted CA certificate that imported into Ping Federate server. You may select \\\"Trust Any\\\" to trust all the existing issuers in Ping Federate server. Used in conjunction with ping-cert-subject-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_issuer_dn: Option<String>,
    #[schemars(description = "Base64-encoded JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT (Sign Algo: RS256) and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks: Option<String>,
    #[schemars(description = "The URL of the JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user password")]
    ping_password: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    ping_privileged_user: Option<String>,
    #[schemars(description = "List of URIs to which the OAuth authorization server may redirect the resource owner's user agent after authorization is obtained. At least one redirection URI is required for the AUTHORIZATION_CODE and IMPLICIT grant types.")]
    ping_redirect_uris: Option<Vec<String>>,
    #[schemars(description = "Limit the OAuth client to specific scopes list")]
    ping_restricted_scopes: Option<Vec<String>>,
    #[schemars(description = "The signing algorithm that the client must use to sign its request objects [RS256,RS384,RS512,ES256,ES384,ES512,PS256,PS384,PS512] If no explicit value is given, the client can use any of the supported signing algorithms (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_signing_algo: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The time from dynamic secret creation to expiration.")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdatePostgreSqlInput {
    #[schemars(description = "PostgreSQL Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "PostgreSQL DB Name")]
    postgresql_db_name: Option<String>,
    #[schemars(description = "PostgreSQL Host")]
    postgresql_host: Option<String>,
    #[schemars(description = "PostgreSQL Password")]
    postgresql_password: Option<String>,
    #[schemars(description = "PostgreSQL Port")]
    postgresql_port: Option<String>,
    #[schemars(description = "PostgreSQL Username")]
    postgresql_username: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "PostgreSQL Revocation statements")]
    revocation_statement: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateRabbitMqInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RabbitMQ Admin password")]
    rabbitmq_admin_pwd: Option<String>,
    #[schemars(description = "RabbitMQ Admin User")]
    rabbitmq_admin_user: Option<String>,
    #[schemars(description = "Server URI")]
    rabbitmq_server_uri: Option<String>,
    #[schemars(description = "User configuration permission")]
    rabbitmq_user_conf_permission: Option<String>,
    #[schemars(description = "User read permission")]
    rabbitmq_user_read_permission: Option<String>,
    #[schemars(description = "User Tags")]
    rabbitmq_user_tags: Option<String>,
    #[schemars(description = "User Virtual Host")]
    rabbitmq_user_vhost: Option<String>,
    #[schemars(description = "User write permission")]
    rabbitmq_user_write_permission: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateRdpInput {
    #[schemars(description = "AllowUserExtendSession")]
    allow_user_extend_session: Option<i64>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for fixed-user-only=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Allow access using externally (IdP) provided username [true/false]")]
    fixed_user_only: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RDP Admin Name")]
    rdp_admin_name: Option<String>,
    #[schemars(description = "RDP Admin password")]
    rdp_admin_pwd: Option<String>,
    #[schemars(description = "Hostname")]
    rdp_host_name: Option<String>,
    #[schemars(description = "Port")]
    rdp_host_port: Option<String>,
    #[schemars(description = "Groups")]
    rdp_user_groups: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "WarnBeforeUserExpiration")]
    warn_user_before_expiration: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateRedisInput {
    #[schemars(description = "A JSON array list of redis ACL rules to attach to the created user. For available rules see the ACL CAT command https://redis.io/commands/acl-cat By default the user will have permissions to read all keys '[\"~*\", \"+@read\"]'")]
    acl_rules: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Redis Host")]
    host: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Redis Password")]
    password: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Redis Port")]
    port: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Redis Username")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateRedshiftInput {
    #[schemars(description = "Redshift Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "Redshift DB Name")]
    redshift_db_name: Option<String>,
    #[schemars(description = "Redshift Host")]
    redshift_host: Option<String>,
    #[schemars(description = "Redshift Password")]
    redshift_password: Option<String>,
    #[schemars(description = "Redshift Port")]
    redshift_port: Option<String>,
    #[schemars(description = "Redshift Username")]
    redshift_username: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateSnowflakeInput {
    #[schemars(description = "Account name")]
    account: Option<String>,
    #[schemars(description = "Database Password")]
    account_password: Option<String>,
    #[schemars(description = "Database Username")]
    account_username: Option<String>,
    #[schemars(description = "The authentication mode for the temporary user [password/key]")]
    auth_mode: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Database name")]
    db_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    key_algo: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    private_key_passphrase: Option<String>,
    #[schemars(description = "User role")]
    role: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Warehouse name")]
    warehouse: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DynamicSecretUpdateVenafiInput {
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Allow subdomains")]
    allow_subdomains: Option<bool>,
    #[schemars(description = "Allowed domains")]
    allowed_domains: Option<Vec<String>>,
    #[schemars(description = "Auto generated folder")]
    auto_generated_folder: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Root first in chain")]
    root_first_in_chain: Option<bool>,
    #[schemars(description = "Use Akeyless PKI issuer or Venafi issuer")]
    sign_using_akeyless_pki: Option<bool>,
    #[schemars(description = "Signer key name")]
    signer_key_name: Option<String>,
    #[schemars(description = "Store private key")]
    store_private_key: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL in time.Duration format (2160h / 129600m / etc...). When using sign-using-akeyless-pki certificates created will have this validity period, otherwise the user-ttl is taken from the Validity Period field of the Zone's' Issuing Template. When using cert-manager it is advised to have a TTL of above 60 days (1440h). For more information - https://cert-manager.io/docs/usage/certificate/")]
    user_ttl: Option<String>,
    #[schemars(description = "Venafi Access Token to use to access the TPP environment (Relevant when using TPP)")]
    venafi_access_token: Option<String>,
    #[schemars(description = "Venafi API key")]
    venafi_api_key: Option<String>,
    #[schemars(description = "Venafi Baseurl")]
    venafi_baseurl: Option<String>,
    #[schemars(description = "Venafi Client ID that was used when the access token was generated")]
    venafi_client_id: Option<String>,
    #[schemars(description = "Venafi Refresh Token to use when the Access Token is expired (Relevant when using TPP)")]
    venafi_refresh_token: Option<String>,
    #[schemars(description = "Venafi using TPP")]
    venafi_use_tpp: Option<bool>,
    #[schemars(description = "Venafi Zone")]
    venafi_zone: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EncryptInput {
    #[schemars(description = "The display id of the key to use in the encryption process")]
    display_id: Option<String>,
    #[schemars(description = "name-value pair that specifies the encryption context to be used for authenticated encryption. If used here, the same value must be supplied to the decrypt command or decryption will fail")]
    encryption_context: Option<serde_json::Value>,
    #[schemars(description = "Select default assumed format for any plaintext input. Currently supported options: [base64]")]
    input_format: Option<String>,
    #[schemars(description = "The item id of the key to use in the encryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the encryption process")]
    key_name: String,
    #[schemars(description = "Data to be encrypted")]
    plaintext: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "key version (relevant only for classic key)")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EncryptGpgInput {
    #[schemars(description = "The display id of the key to use in the encryption process")]
    display_id: Option<String>,
    #[schemars(description = "If specified, the plaintext input is assumed to be formatted accordingly. Current supported options: [base64]")]
    input_format: Option<String>,
    #[schemars(description = "The item id of the key to use in the encryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the encryption process")]
    key_name: String,
    #[schemars(description = "Data to be encrypted")]
    plaintext: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EncryptWithClassicKeyInput {
    #[schemars(description = "The name of the key to use in the encryption process")]
    display_id: String,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Data to be encrypted")]
    plaintext: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EsmCreateInput {
    #[schemars(description = "Use this option if the external secret value is a base64 encoded binary")]
    binary_value: Option<bool>,
    #[schemars(description = "Description of the external secret")]
    description: Option<String>,
    #[schemars(description = "Name of the External Secrets Manager item")]
    esm_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Name for the new external secret")]
    secret_name: String,
    #[schemars(description = "Tags for the external secret")]
    tags: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Value of the external secret item, either text or base64 encoded binary")]
    value: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EsmDeleteInput {
    #[schemars(description = "Name of the External Secrets Manager item")]
    esm_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The external secret id (or name, for AWS, Azure or K8s targets) to delete")]
    secret_id: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EsmGetInput {
    #[schemars(description = "Name of the External Secrets Manager item")]
    esm_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The secret id (or name, for AWS, Azure or K8s targets) to get from the External Secrets Manager")]
    secret_id: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EsmListInput {
    #[schemars(description = "Name of the External Secrets Manager item")]
    esm_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EsmUpdateInput {
    #[schemars(description = "Use this option if the external secret value is a base64 encoded binary")]
    binary_value: Option<bool>,
    #[schemars(description = "Description of the external secret")]
    description: Option<String>,
    #[schemars(description = "Name of the External Secrets Manager item")]
    esm_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The external secret id (or name, for AWS, Azure or K8s targets) to update")]
    secret_id: String,
    #[schemars(description = "Tags for the external secret")]
    tags: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Value of the external secret item, either text or base64 encoded binary")]
    value: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventActionInput {
    #[schemars(description = "The Event Action [approve/deny]")]
    action: String,
    #[schemars(description = "The Event ID")]
    event_id: i64,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderCreateEmailInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of email addresses to send event to")]
    email_to: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Rate of periodic runner repetition in hours")]
    every: Option<String>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Set this option to include event errors details [true/false]")]
    include_error: Option<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "Override Akeyless default URL with your Gateway url (port 18888)")]
    override_url: Option<String>,
    runner_type: String,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderCreateServiceNowInput {
    #[schemars(description = "Workstation Admin Name")]
    admin_name: Option<String>,
    #[schemars(description = "Workstation Admin Password")]
    admin_pwd: Option<String>,
    #[schemars(description = "The RSA Private Key to use when connecting with jwt authentication")]
    app_private_key_base64: Option<String>,
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "The authentication type to use [user-pass/jwt]")]
    auth_type: Option<String>,
    #[schemars(description = "The client ID to use when connecting with jwt authentication")]
    client_id: Option<String>,
    #[schemars(description = "The client secret to use when connecting with jwt authentication")]
    client_secret: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Rate of periodic runner repetition in hours")]
    every: Option<String>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Workstation Host")]
    host: Option<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    runner_type: String,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The user email to identify with when connecting with jwt authentication")]
    user_email: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderCreateSlackInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Rate of periodic runner repetition in hours")]
    every: Option<String>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    runner_type: String,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Slack Webhook URL")]
    url: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderCreateTeamsInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Rate of periodic runner repetition in hours")]
    every: Option<String>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    runner_type: String,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Teams Webhook URL")]
    url: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderCreateWebhookInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Base64 encoded Token string for authentication type Token")]
    auth_token: Option<String>,
    #[schemars(description = "The Webhook authentication type [user-pass, bearer-token, certificate]")]
    auth_type: Option<String>,
    #[schemars(description = "Base64 encoded PEM certificate, relevant for certificate auth-type")]
    client_cert_data: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Rate of periodic runner repetition in hours")]
    every: Option<String>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "Password for authentication relevant for user-pass auth-type")]
    password: Option<String>,
    #[schemars(description = "Base64 encoded PEM RSA Private Key, relevant for certificate auth-type")]
    private_key_data: Option<String>,
    runner_type: String,
    #[schemars(description = "Base64 encoded PEM certificate of the Webhook")]
    server_certificates: Option<String>,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Webhook URL")]
    url: Option<String>,
    #[schemars(description = "Username for authentication relevant for user-pass auth-type")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderDeleteInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderGetInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderUpdateEmailInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of email addresses to send event to")]
    email_to: Option<String>,
    #[schemars(description = "Enable/Disable Event Forwarder [true/false]")]
    enable: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Set this option to include event errors details [true/false]")]
    include_error: Option<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "New EventForwarder name")]
    new_name: Option<String>,
    #[schemars(description = "Override Akeyless default URL with your Gateway url (port 18888)")]
    override_url: Option<String>,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderUpdateServiceNowInput {
    #[schemars(description = "Workstation Admin Name")]
    admin_name: Option<String>,
    #[schemars(description = "Workstation Admin Password")]
    admin_pwd: Option<String>,
    #[schemars(description = "The RSA Private Key to use when connecting with jwt authentication")]
    app_private_key_base64: Option<String>,
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "The authentication type to use [user-pass/jwt]")]
    auth_type: Option<String>,
    #[schemars(description = "The client ID to use when connecting with jwt authentication")]
    client_id: Option<String>,
    #[schemars(description = "The client secret to use when connecting with jwt authentication")]
    client_secret: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable/Disable Event Forwarder [true/false]")]
    enable: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Workstation Host")]
    host: Option<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "New EventForwarder name")]
    new_name: Option<String>,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The user email to identify with when connecting with jwt authentication")]
    user_email: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderUpdateSlackInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable/Disable Event Forwarder [true/false]")]
    enable: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "New EventForwarder name")]
    new_name: Option<String>,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Slack Webhook URL")]
    url: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderUpdateTeamsInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable/Disable Event Forwarder [true/false]")]
    enable: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "New EventForwarder name")]
    new_name: Option<String>,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Teams Webhook URL")]
    url: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct EventForwarderUpdateWebhookInput {
    #[schemars(description = "Auth Method Event sources")]
    auth_methods_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Base64 encoded Token string for authentication type Token")]
    auth_token: Option<String>,
    #[schemars(description = "The Webhook authentication type [user-pass, bearer-token, certificate]")]
    auth_type: Option<String>,
    #[schemars(description = "Base64 encoded PEM certificate, relevant for certificate auth-type")]
    client_cert_data: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable/Disable Event Forwarder [true/false]")]
    enable: Option<String>,
    #[schemars(description = "List of event types to notify about [request-access, certificate-pending-expiration, certificate-expired, certificate-provisioning-success, certificate-provisioning-failure, auth-method-pending-expiration, auth-method-expired, next-automatic-rotation, rotated-secret-success, rotated-secret-failure, dynamic-secret-failure, multi-auth-failure, uid-rotation-failure, apply-justification, email-auth-method-approved, usage, rotation-usage, gateway-inactive, static-secret-updated, rate-limiting, usage-report, secret-sync]")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Event sources")]
    gateways_event_source_locations: Vec<String>,
    #[schemars(description = "Items Event sources")]
    items_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the EventForwarder secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "New EventForwarder name")]
    new_name: Option<String>,
    #[schemars(description = "Password for authentication relevant for user-pass auth-type")]
    password: Option<String>,
    #[schemars(description = "Base64 encoded PEM RSA Private Key, relevant for certificate auth-type")]
    private_key_data: Option<String>,
    #[schemars(description = "Base64 encoded PEM certificate of the Webhook")]
    server_certificates: Option<String>,
    #[schemars(description = "Targets Event sources")]
    targets_event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Webhook URL")]
    url: Option<String>,
    #[schemars(description = "Username for authentication relevant for user-pass auth-type")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ExportClassicKeyInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Use this option to output only public key")]
    export_public_key: Option<bool>,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "ClassicKey name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Classic key version")]
    version: Option<i64>,
    #[schemars(description = "Classic key name to wrap the key material with")]
    wrapping_key_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct FolderCreateInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Folder name")]
    name: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct FolderDeleteInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Folder name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct FolderGetInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Folder name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct FolderUpdateInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "List of the new tags that will be attached to this folder")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Folder name")]
    name: String,
    #[schemars(description = "List of the existent tags that will be removed from this folder")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateAllowedAccessInput {
    sub_claims_case_insensitive: Option<bool>,
    #[schemars(description = "Access ID The access id to be attached to this allowed access. Auth method with this access id should already exist.")]
    access_id: String,
    #[schemars(description = "Treat sub claims as case-sensitive [true/false]")]
    case_sensitive: Option<String>,
    #[schemars(description = "Allowed access description")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Allowed access name")]
    name: String,
    #[schemars(description = "Permissions  Comma-seperated list of permissions for this allowed access. Available permissions: [defaults,targets,classic_keys,automatic_migration,ldap_auth,dynamic_secret,k8s_auth,log_forwarding,zero_knowledge_encryption,rotated_secret,caching,event_forwarding,admin,kmip,general,rotate_secret_value]")]
    permissions: Option<String>,
    #[schemars(description = "Sub claims key/val of sub claims, e.g group=admins,developers")]
    sub_claims: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateK8sAuthConfigInput {
    #[schemars(description = "The access ID of the Kubernetes auth method")]
    access_id: String,
    #[schemars(description = "Cluster access type. options: [native_k8s, rancher]")]
    cluster_api_type: Option<String>,
    #[schemars(description = "Disable issuer validation [true/false]")]
    disable_issuer_validation: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S auth type [token/certificate]. (relevant for \"native_k8s\" only)")]
    k8s_auth_type: Option<String>,
    #[schemars(description = "The CA Certificate (base64 encoded) to use to call into the kubernetes API server")]
    k8s_ca_cert: Option<String>,
    #[schemars(description = "Content of the k8 client certificate (PEM format) in a Base64 format (relevant for \"native_k8s\" only)")]
    k8s_client_certificate: Option<String>,
    #[schemars(description = "Content of the k8 client private key (PEM format) in a Base64 format (relevant for \"native_k8s\" only)")]
    k8s_client_key: Option<String>,
    #[schemars(description = "The URL of the kubernetes API server")]
    k8s_host: String,
    #[schemars(description = "The Kubernetes JWT issuer name. K8SIssuer is the claim that specifies who issued the Kubernetes token")]
    k8s_issuer: Option<String>,
    #[schemars(description = "K8S Auth config name")]
    name: String,
    #[schemars(description = "The api key used to access the TokenReview API to validate other JWTs (relevant for \"rancher\" only)")]
    rancher_api_key: Option<String>,
    #[schemars(description = "The cluster id as define in rancher (relevant for \"rancher\" only)")]
    rancher_cluster_id: Option<String>,
    #[schemars(description = "The private key (base64 encoded) associated with the public key defined in the Kubernetes auth")]
    signing_key: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Time in seconds of expiration of the Akeyless Kube Auth Method token")]
    token_exp: Option<i64>,
    #[schemars(description = "A Kubernetes service account JWT used to access the TokenReview API to validate other JWTs (relevant for \"native_k8s\" only). If not set, the JWT submitted in the authentication process will be used to access the Kubernetes TokenReview API.")]
    token_reviewer_jwt: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateMigrationInput {
    service_account_key_decoded: Option<String>,
    #[schemars(description = "Enable/Disable automatic/recurrent rotation for migrated secrets. Default is false: only manual rotation is allowed for migrated secrets. If set to true, this command should be combined with --ad-rotation-interval and --ad-rotation-hour parameters (Relevant only for Active Directory migration)")]
    ad_auto_rotate: Option<String>,
    #[schemars(description = "How many days before the expiration of discovered certificates would you like to be notified (Relevant only for Active Directory migration with certificate discovery enabled)")]
    ad_cert_expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Path location template for migrating certificates e.g.: /Certificates/{{COMMON_NAME}} (Relevant only for Active Directory migration with certificate discovery enabled)")]
    ad_certificates_path_template: Option<String>,
    #[schemars(description = "Distinguished Name of Computer objects (servers) to search in Active Directory e.g.: CN=Computers,DC=example,DC=com (Relevant only for Active Directory migration)")]
    ad_computer_base_dn: Option<String>,
    #[schemars(description = "Enable/Disable discovery of IIS application from each domain server as part of the SSH/Windows Rotated Secrets. Default is false. (Relevant only for Active Directory migration)")]
    ad_discover_iis_app: Option<String>,
    #[schemars(description = "Enable/Disable discovery of Windows services from each domain server as part of the SSH/Windows Rotated Secrets. Default is false. (Relevant only for Active Directory migration)")]
    ad_discover_services: Option<String>,
    #[schemars(description = "Set migration discovery types (domain-users, computers, local-users). (Relevant only for Active Directory migration)")]
    ad_discovery_types: Option<Vec<String>>,
    #[schemars(description = "Active Directory Domain Name (Relevant only for Active Directory migration)")]
    ad_domain_name: Option<String>,
    #[schemars(description = "Path location template for migrating domain users as Rotated Secrets e.g.: .../DomainUsers/{{USERNAME}} (Relevant only for Active Directory migration)")]
    ad_domain_users_path_template: Option<String>,
    #[schemars(description = "Comma-separated list of Local Users which should not be migrated (Relevant only for Active Directory migration)")]
    ad_local_users_ignore: Option<String>,
    #[schemars(description = "Path location template for migrating domain users as Rotated Secrets e.g.: .../LocalUsers/{{COMPUTER_NAME}}/{{USERNAME}} (Relevant only for Active Directory migration)")]
    ad_local_users_path_template: Option<String>,
    #[schemars(description = "Filter by Operating System to run the migration, can be used with wildcards, e.g. SRV20* (Relevant only for Active Directory migration)")]
    ad_os_filter: Option<String>,
    #[schemars(description = "The hour of the scheduled rotation in UTC (Relevant only for Active Directory migration)")]
    ad_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic rotation [1-365] (Relevant only for Active Directory migration)")]
    ad_rotation_interval: Option<i64>,
    #[schemars(description = "Enable/Disable RDP Secure Remote Access for the migrated local users rotated secrets. Default is false: rotated secrets will not be created with SRA (Relevant only for Active Directory migration)")]
    ad_sra_enable_rdp: Option<String>,
    #[schemars(description = "Set the SSH Port for further connection to the domain servers. Default is port 22 (Relevant only for Active Directory migration)")]
    ad_ssh_port: Option<String>,
    #[schemars(description = "Relevant only for ad-discovery-types=computers. For linked, all computers will be migrated into a linked target(s). if set with regular, the migration will create a target for each computer.")]
    ad_target_format: Option<String>,
    #[schemars(description = "Active Directory LDAP Target Name. Server type should be Active Directory (Relevant only for Active Directory migration)")]
    ad_target_name: Option<String>,
    #[schemars(description = "Path location template for migrating domain servers as SSH/Windows Targets e.g.: .../Servers/{{COMPUTER_NAME}} (Relevant only for Active Directory migration)")]
    ad_targets_path_template: Option<String>,
    #[schemars(description = "Set the target type of the domain servers [ssh/windows](Relevant only for Active Directory migration)")]
    ad_targets_type: Option<String>,
    #[schemars(description = "Distinguished Name of User objects to search in Active Directory, e.g.: CN=Users,DC=example,DC=com (Relevant only for Active Directory migration)")]
    ad_user_base_dn: Option<String>,
    #[schemars(description = "Comma-separated list of domain groups from which privileged domain users will be migrated. If empty, migrate all users based on the --ad-user-base-dn (Relevant only for Active Directory migration)")]
    ad_user_groups: Option<String>,
    #[schemars(description = "Use WinRM over HTTP, by default runs over HTTPS")]
    ad_winrm_over_http: Option<String>,
    #[schemars(description = "Set the WinRM Port for further connection to the domain servers. Default is 5986 (Relevant only for Active Directory migration)")]
    ad_winrm_port: Option<String>,
    #[schemars(description = "Enable/Disable discovery of local users from each domain server and migrate them as SSH/Windows Rotated Secrets. Default is false: only domain users will be migrated. Discovery of local users might require further installation of SSH on the servers, based on the supplied computer base DN. This will be implemented automatically as part of the migration process (Relevant only for Active Directory migration) Deprecated: use AdDiscoverTypes")]
    ad_discover_local_users: Option<String>,
    #[schemars(description = "Enable AI-assisted certificate discovery (only when AI Insight is enabled on the Gateway)")]
    ai_certificate_discovery: Option<String>,
    #[schemars(description = "AWS Secret Access Key (relevant only for AWS migration)")]
    aws_key: Option<String>,
    #[schemars(description = "AWS Access Key ID with sufficient permissions to get all secrets, e.g. 'arn:aws:secretsmanager:[Region]:[AccountId]:secret:[/path/to/secrets/*]' (relevant only for AWS migration)")]
    aws_key_id: Option<String>,
    #[schemars(description = "AWS region of the required Secrets Manager (relevant only for AWS migration)")]
    aws_region: Option<String>,
    #[schemars(description = "Azure Key Vault Access client ID, should be Azure AD App with a service principal (relevant only for Azure Key Vault migration)")]
    azure_client_id: Option<String>,
    #[schemars(description = "Azure Key Vault Name (relevant only for Azure Key Vault migration)")]
    azure_kv_name: Option<String>,
    #[schemars(description = "Azure Key Vault secret (relevant only for Azure Key Vault migration)")]
    azure_secret: Option<String>,
    #[schemars(description = "Azure Key Vault Access tenant ID (relevant only for Azure Key Vault migration)")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "Conjur account name set on your Conjur server (relevant only for Conjur migration).")]
    conjur_account: Option<String>,
    #[schemars(description = "Conjur API Key for the specified user (relevant only for Conjur migration).")]
    conjur_api_key: Option<String>,
    #[schemars(description = "Conjur server base URL (relevant only for Conjur migration). If conjur-url is HTTPS and Conjur uses a private CA/self-signed certificate, make the CA bundle available on the Gateway and set CONJUR_SSL_CERT_PATH to its path.")]
    conjur_url: Option<String>,
    #[schemars(description = "Conjur username used to authenticate (relevant only for Conjur migration).")]
    conjur_username: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Base64-encoded GCP Service Account private key text with sufficient permissions to Secrets Manager, Minimum required permission is Secret Manager Secret Accessor, e.g. 'roles/secretmanager.secretAccessor' (relevant only for GCP migration)")]
    gcp_key: Option<String>,
    #[schemars(description = "GCP Project ID (cross-project override)")]
    gcp_project_id: Option<String>,
    #[schemars(description = "Import secret key as json value or independent secrets (relevant only for HasiCorp Vault migration) [true/false]")]
    hashi_json: Option<String>,
    #[schemars(description = "HashiCorp Vault Namespaces is a comma-separated list of namespaces which need to be imported into Akeyless Vault. For every provided namespace, all its child namespaces are imported as well, e.g. nmsp/subnmsp1/subnmsp2,nmsp/anothernmsp. By default, import all namespaces (relevant only for HasiCorp Vault migration)")]
    hashi_ns: Option<Vec<String>>,
    #[schemars(description = "HashiCorp Vault access token with sufficient permissions to preform list & read operations on secrets objects (relevant only for HasiCorp Vault migration)")]
    hashi_token: Option<String>,
    #[schemars(description = "HashiCorp Vault API URL, e.g. https://vault-mgr01:8200 (relevant only for HasiCorp Vault migration)")]
    hashi_url: Option<String>,
    #[schemars(description = "A comma separated list of IPs, CIDR ranges, or DNS names to scan")]
    hosts: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "For Certificate Authentication method K8s Cluster CA certificate (relevant only for K8s migration with Certificate Authentication method)")]
    k8s_ca_certificate: Option<Vec<i64>>,
    #[schemars(description = "K8s Client certificate with sufficient permission to list and get secrets in the namespace(s) you selected (relevant only for K8s migration with Certificate Authentication method)")]
    k8s_client_certificate: Option<Vec<i64>>,
    #[schemars(description = "K8s Client key (relevant only for K8s migration with Certificate Authentication method)")]
    k8s_client_key: Option<Vec<i64>>,
    #[schemars(description = "K8s Namespace, Use this field to import secrets from a particular namespace only. By default, the secrets are imported from all namespaces (relevant only for K8s migration)")]
    k8s_namespace: Option<String>,
    #[schemars(description = "K8s Client password (relevant only for K8s migration with Password Authentication method)")]
    k8s_password: Option<String>,
    #[schemars(description = "K8s Skip Control Plane Secrets, This option allows to avoid importing secrets from system namespaces (relevant only for K8s migration)")]
    k8s_skip_system: Option<bool>,
    #[schemars(description = "For Token Authentication method K8s Bearer Token with sufficient permission to list and get secrets in the namespace(s) you selected (relevant only for K8s migration with Token Authentication method)")]
    k8s_token: Option<String>,
    #[schemars(description = "K8s API Server URL, e.g. https://k8s-api.mycompany.com:6443 (relevant only for K8s migration)")]
    k8s_url: Option<String>,
    #[schemars(description = "For Password Authentication method K8s Client username with sufficient permission to list and get secrets in the namespace(s) you selected (relevant only for K8s migration with Password Authentication method)")]
    k8s_username: Option<String>,
    #[schemars(description = "Migration name")]
    name: String,
    #[schemars(description = "A comma separated list of port ranges Examples: \"80,443\" or \"80,443,8080-8090\" or \"443\"")]
    port_ranges: Option<String>,
    #[schemars(description = "The name of the key that protects the classic key value (if empty, the account default key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "Enable/Disable automatic/recurrent rotation for migrated secrets. Default is false: only manual rotation is allowed for migrated secrets. If set to true, this command should be combined with --si-rotation-interval and --si-rotation-hour parameters (Relevant only for Server Inventory migration)")]
    si_auto_rotate: Option<String>,
    #[schemars(description = "The hour of the scheduled rotation in UTC (Relevant only for Server Inventory migration)")]
    si_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic rotation [1-365] (Relevant only for Server Inventory migration)")]
    si_rotation_interval: Option<i64>,
    #[schemars(description = "Enable/Disable RDP Secure Remote Access for the migrated local users rotated secrets. Default is false: rotated secrets will not be created with SRA (Relevant only for Server Inventory migration)")]
    si_sra_enable_rdp: Option<String>,
    #[schemars(description = "SSH, Windows or Linked Target Name. (Relevant only for Server Inventory migration)")]
    si_target_name: String,
    #[schemars(description = "Comma-separated list of groups to migrate users from. If empty, all users from all groups will be migrated (Relevant only for Server Inventory migration)")]
    si_user_groups: Option<String>,
    #[schemars(description = "Comma-separated list of Local Users which should not be migrated (Relevant only for Server Inventory migration)")]
    si_users_ignore: Option<String>,
    #[schemars(description = "Path location template for migrating users as Rotated Secrets e.g.: .../Users/{{COMPUTER_NAME}}/{{USERNAME}} (Relevant only for Server Inventory migration)")]
    si_users_path_template: String,
    #[schemars(description = "Target location in Akeyless for imported secrets")]
    target_location: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Migration type (hashi/aws/gcp/k8s/azure_kv/conjur/active_directory/server_inventory/certificate)")]
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerRedisInput {
    #[schemars(description = "A JSON array list of redis ACL rules to attach to the created user. For available rules see the ACL CAT command https://redis.io/commands/acl-cat By default the user will have permissions to read all keys '[\"~*\", \"+@read\"]'")]
    acl_rules: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Redis Host")]
    host: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Redis Password")]
    password: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Redis Port")]
    port: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Redis Username")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerArtifactoryInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: Option<String>,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: Option<String>,
    #[schemars(description = "Token Audience")]
    artifactory_token_audience: String,
    #[schemars(description = "Token Scope")]
    artifactory_token_scope: String,
    #[schemars(description = "Base URL")]
    base_url: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerAwsInput {
    access_mode: Option<String>,
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Access Key ID")]
    aws_access_key_id: Option<String>,
    #[schemars(description = "Secret Access Key")]
    aws_access_secret_key: Option<String>,
    #[schemars(description = "The AWS External ID associated with the AWS role (relevant only for assume_role mode)")]
    aws_external_id: Option<String>,
    #[schemars(description = "AWS Role ARNs to be used in the Assume Role operation (relevant only for assume_role mode)")]
    aws_role_arns: Option<String>,
    #[schemars(description = "AWS User console access")]
    aws_user_console_access: Option<bool>,
    #[schemars(description = "AWS User groups")]
    aws_user_groups: Option<String>,
    #[schemars(description = "AWS User policies")]
    aws_user_policies: Option<String>,
    #[schemars(description = "Enable AWS User programmatic access")]
    aws_user_programmatic_access: Option<bool>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Region")]
    region: Option<String>,
    #[schemars(description = "The AWS account id")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "String of Key value session tags comma separated, relevant only for Assumed Role")]
    session_tags: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "String of transitive tag keys space separated, relevant only for Assumed Role")]
    transitive_tag_keys: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerAzureInput {
    #[schemars(description = "Azure App Object Id")]
    app_obj_id: Option<String>,
    #[schemars(description = "Azure AD administrative unit (relevant only when azure-user-portal-access=true)")]
    azure_administrative_unit: Option<String>,
    #[schemars(description = "Azure Client ID")]
    azure_client_id: Option<String>,
    #[schemars(description = "Azure Client Secret")]
    azure_client_secret: Option<String>,
    #[schemars(description = "Azure Tenant ID")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "FixedUserClaimKeyname")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Fixed user")]
    fixed_user_only: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic secret encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Group Object Id")]
    user_group_obj_id: Option<String>,
    #[schemars(description = "Azure User portal access")]
    user_portal_access: Option<bool>,
    #[schemars(description = "User Principal Name")]
    user_principal_name: Option<String>,
    #[schemars(description = "Azure User programmatic access")]
    user_programmatic_access: Option<bool>,
    #[schemars(description = "User Role Template Id")]
    user_role_template_id: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerCassandraInput {
    #[schemars(description = "Cassandra creation statements")]
    cassandra_creation_statements: Option<String>,
    #[schemars(description = "Cassandra hosts IP or addresses, comma separated")]
    cassandra_hosts: Option<String>,
    #[schemars(description = "Cassandra superuser password")]
    cassandra_password: Option<String>,
    #[schemars(description = "Cassandra port")]
    cassandra_port: Option<String>,
    #[schemars(description = "Cassandra superuser username")]
    cassandra_username: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerVenafiInput {
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Allow subdomains")]
    allow_subdomains: Option<bool>,
    #[schemars(description = "Allowed domains")]
    allowed_domains: Option<Vec<String>>,
    #[schemars(description = "Auto generated folder")]
    auto_generated_folder: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Root first in chain")]
    root_first_in_chain: Option<bool>,
    #[schemars(description = "Use Akeyless PKI issuer or Venafi issuer")]
    sign_using_akeyless_pki: Option<bool>,
    #[schemars(description = "Signer key name")]
    signer_key_name: Option<String>,
    #[schemars(description = "Store private key")]
    store_private_key: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL in time.Duration format (2160h / 129600m / etc...). When using sign-using-akeyless-pki certificates created will have this validity period, otherwise the user-ttl is taken from the Validity Period field of the Zone's' Issuing Template. When using cert-manager it is advised to have a TTL of above 60 days (1440h). For more information - https://cert-manager.io/docs/usage/certificate/")]
    user_ttl: Option<String>,
    #[schemars(description = "Venafi Access Token to use to access the TPP environment (Relevant when using TPP)")]
    venafi_access_token: Option<String>,
    #[schemars(description = "Venafi API key")]
    venafi_api_key: Option<String>,
    #[schemars(description = "Venafi Baseurl")]
    venafi_baseurl: Option<String>,
    #[schemars(description = "Venafi Client ID that was used when the access token was generated")]
    venafi_client_id: Option<String>,
    #[schemars(description = "Venafi Refresh Token to use when the Access Token is expired (Relevant when using TPP)")]
    venafi_refresh_token: Option<String>,
    #[schemars(description = "Venafi using TPP")]
    venafi_use_tpp: Option<bool>,
    #[schemars(description = "Venafi Zone")]
    venafi_zone: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerChefInput {
    #[schemars(description = "Organizations")]
    chef_orgs: Option<String>,
    #[schemars(description = "Server key")]
    chef_server_key: Option<String>,
    #[schemars(description = "Server URL")]
    chef_server_url: Option<String>,
    #[schemars(description = "Server username")]
    chef_server_username: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Skip SSL")]
    skip_ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerCustomInput {
    #[schemars(description = "Define rotation interval in days")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "URL of an endpoint that implements /sync/create method, for example https://webhook.example.com/sync/create")]
    create_sync_url: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Should admin credentials be rotated")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Secret payload to be sent with each create/revoke webhook request")]
    payload: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "URL of an endpoint that implements /sync/revoke method, for example https://webhook.example.com/sync/revoke")]
    revoke_sync_url: String,
    #[schemars(description = "URL of an endpoint that implements /sync/rotate method, for example https://webhook.example.com/sync/rotate")]
    rotate_sync_url: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Maximum allowed time in seconds for the webhook to return the results")]
    timeout_sec: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerDockerhubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "DockerhubPassword is either the user's password access token to manage the repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Access token scopes list (comma-separated) to give the dynamic secret valid options are in \"repo:admin\", \"repo:write\", \"repo:read\", \"repo:public_read\"")]
    dockerhub_token_scopes: Option<String>,
    #[schemars(description = "DockerhubUsername is the name of the user in dockerhub")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerEksInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: Option<String>,
    #[schemars(description = "IAM assume role")]
    eks_assume_role: Option<String>,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: Option<String>,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: Option<String>,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: Option<String>,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerGcpInput {
    access_type: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (Relevant only when --access-type=external)")]
    fixed_user_claim_keyname: Option<String>,
    gcp_cred_type: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Service account key algorithm, e.g. KEY_ALG_RSA_1024 (Relevant only when --access-type=sa and --gcp-cred-type=key)")]
    gcp_key_algo: Option<String>,
    #[schemars(description = "GCP Project ID override for dynamic secret operations")]
    gcp_project_id: Option<String>,
    #[schemars(description = "The email of the fixed service account to generate keys or tokens for (Relevant only when --access-type=sa and --service-account-type=fixed)")]
    gcp_sa_email: Option<String>,
    #[schemars(description = "Access token scopes list, e.g. scope1,scope2 (Relevant only when --access-type=sa; required when --gcp-cred-type=token)")]
    gcp_token_scopes: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Role binding definitions in JSON format (Relevant only when --access-type=sa and --service-account-type=dynamic)")]
    role_binding: Option<String>,
    #[schemars(description = "Comma-separated list of GCP roles to assign to the user (Relevant only when --access-type=external)")]
    role_names: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "The type of the GCP service account. Options [fixed, dynamic] (Relevant only when --access-type=sa)")]
    service_account_type: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerGithubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "GitHub application installation id")]
    installation_id: Option<i64>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub organization name")]
    installation_organization: Option<String>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub repository '<owner>/<repo-name>'")]
    installation_repository: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Optional - installation token's allowed permissions")]
    token_permissions: Option<Vec<String>>,
    #[schemars(description = "Optional - installation token's allowed repositories")]
    token_repositories: Option<Vec<String>>,
    #[schemars(description = "Token TTL")]
    token_ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerGkeInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerHanaDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "HanaDb Name")]
    hana_dbname: Option<String>,
    #[schemars(description = "HanaDb Creation statements")]
    hanadb_create_statements: Option<String>,
    #[schemars(description = "HanaDb Host")]
    hanadb_host: Option<String>,
    #[schemars(description = "HanaDb Password")]
    hanadb_password: Option<String>,
    #[schemars(description = "HanaDb Port")]
    hanadb_port: Option<String>,
    #[schemars(description = "HanaDb Revocation statements")]
    hanadb_revocation_statements: Option<String>,
    #[schemars(description = "HanaDb Username")]
    hanadb_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerNativeK8sInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Comma-separated list of allowed K8S namespaces for the generated ServiceAccount (relevant only for k8s-service-account-type=dynamic)")]
    k8s_allowed_namespaces: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "K8S Namespace where the ServiceAccount exists.")]
    k8s_namespace: Option<String>,
    #[schemars(description = "The pre-existing Role or ClusterRole name to bind the generated ServiceAccount to (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_name: Option<String>,
    #[schemars(description = "Specifies the type of the pre-existing K8S role [Role, ClusterRole] (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_type: Option<String>,
    #[schemars(description = "Content of the yaml in a Base64 format.")]
    k8s_rolebinding_yaml_data: Option<String>,
    #[schemars(description = "Path to yaml file that contains definitions of K8S role and role binding (relevant only for k8s-service-account-type=dynamic)")]
    k8s_rolebinding_yaml_def: Option<String>,
    #[schemars(description = "K8S ServiceAccount to extract token from.")]
    k8s_service_account: Option<String>,
    #[schemars(description = "K8S ServiceAccount type [fixed, dynamic].")]
    k8s_service_account_type: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The K8s dashboard url")]
    secure_access_dashboard_url: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerLdapInput {
    provider_type: Option<String>,
    #[schemars(description = "Bind DN")]
    bind_dn: Option<String>,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Externally provided username [true/false]")]
    external_username: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for external-username=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Group DN which the temporary user should be added")]
    group_dn: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Attribute")]
    user_attribute: Option<String>,
    #[schemars(description = "User DN")]
    user_dn: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerMongoInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB custom data")]
    mongodb_custom_data: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server host and port")]
    mongodb_host_port: Option<String>,
    #[schemars(description = "MongoDB Name")]
    mongodb_name: Option<String>,
    #[schemars(description = "MongoDB server password. You will prompted to provide a password if it will not appear in CLI parameters")]
    mongodb_password: Option<String>,
    #[schemars(description = "MongoDB Roles")]
    mongodb_roles: Option<String>,
    #[schemars(description = "MongoDB Scopes (Atlas only)")]
    mongodb_scopes: Option<String>,
    #[schemars(description = "MongoDB server URI")]
    mongodb_server_uri: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "MongoDB server username")]
    mongodb_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Encrypt producer with following key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerMssqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CSV of allowed DB names for runtime selection when getting the secret value. Empty => use target DB only; \"*\" => any DB allowed; One or more names => user must choose from this list")]
    mssql_allowed_db_names: Option<String>,
    #[schemars(description = "MSSQL Creation statements")]
    mssql_create_statements: Option<String>,
    #[schemars(description = "MSSQL Name")]
    mssql_dbname: Option<String>,
    #[schemars(description = "MSSQL Host")]
    mssql_host: Option<String>,
    #[schemars(description = "MSSQL Password")]
    mssql_password: Option<String>,
    #[schemars(description = "MSSQL Port")]
    mssql_port: Option<String>,
    #[schemars(description = "MSSQL Revocation statements")]
    mssql_revocation_statements: Option<String>,
    #[schemars(description = "MSSQL Username")]
    mssql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerMySqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MySQL DB Name")]
    mysql_dbname: Option<String>,
    #[schemars(description = "MySQL Host")]
    mysql_host: Option<String>,
    #[schemars(description = "MySQL Password")]
    mysql_password: Option<String>,
    #[schemars(description = "MySQL Port")]
    mysql_port: Option<String>,
    #[schemars(description = "MySQL Revocation statements")]
    mysql_revocation_statements: Option<String>,
    #[schemars(description = "MySQL Creation statements")]
    mysql_screation_statements: Option<String>,
    #[schemars(description = "MySQL Username")]
    mysql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerOracleDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Oracle Host")]
    oracle_host: Option<String>,
    #[schemars(description = "Oracle Password")]
    oracle_password: Option<String>,
    #[schemars(description = "Oracle Port")]
    oracle_port: Option<String>,
    #[schemars(description = "Oracle Revocation statements")]
    oracle_revocation_statements: Option<String>,
    #[schemars(description = "Oracle Creation statements")]
    oracle_screation_statements: Option<String>,
    #[schemars(description = "Oracle DB Name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Username")]
    oracle_username: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerPingInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Ping Federate administrative port")]
    ping_administrative_port: Option<String>,
    #[schemars(description = "Set a specific Access Token Management (ATM) instance for the created OAuth Client by providing the ATM Id. If no explicit value is given, the default pingfederate server ATM will be set.")]
    ping_atm_id: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    ping_authorization_port: Option<String>,
    #[schemars(description = "The subject DN of the client certificate. If no explicit value is given, the producer will create CA certificate and matched client certificate and return it as value. Used in conjunction with ping-issuer-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_cert_subject_dn: Option<String>,
    #[schemars(description = "OAuth Client Authentication Type [CLIENT_SECRET, PRIVATE_KEY_JWT, CLIENT_TLS_CERTIFICATE]")]
    ping_client_authentication_type: Option<String>,
    #[schemars(description = "Determines whether PingFederate requires a unique signed JWT from the client for each action (relevant for PRIVATE_KEY_JWT authentication method) [true/false]")]
    ping_enforce_replay_prevention: Option<String>,
    #[schemars(description = "List of OAuth client grant types [IMPLICIT, AUTHORIZATION_CODE, CLIENT_CREDENTIALS, TOKEN_EXCHANGE, REFRESH_TOKEN, ASSERTION_GRANTS, PASSWORD, RESOURCE_OWNER_CREDENTIALS]. If no explicit value is given, AUTHORIZATION_CODE will be selected as default.")]
    ping_grant_types: Option<Vec<String>>,
    #[schemars(description = "Issuer DN of trusted CA certificate that imported into Ping Federate server. You may select \\\"Trust Any\\\" to trust all the existing issuers in Ping Federate server. Used in conjunction with ping-cert-subject-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_issuer_dn: Option<String>,
    #[schemars(description = "Base64-encoded JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT (Sign Algo: RS256) and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks: Option<String>,
    #[schemars(description = "The URL of the JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user password")]
    ping_password: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    ping_privileged_user: Option<String>,
    #[schemars(description = "List of URIs to which the OAuth authorization server may redirect the resource owner's user agent after authorization is obtained. At least one redirection URI is required for the AUTHORIZATION_CODE and IMPLICIT grant types.")]
    ping_redirect_uris: Option<Vec<String>>,
    #[schemars(description = "Limit the OAuth client to specific scopes list")]
    ping_restricted_scopes: Option<Vec<String>>,
    #[schemars(description = "The signing algorithm that the client must use to sign its request objects [RS256,RS384,RS512,ES256,ES384,ES512,PS256,PS384,PS512] If no explicit value is given, the client can use any of the supported signing algorithms (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_signing_algo: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The time from dynamic secret creation to expiration.")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerPostgreSqlInput {
    #[schemars(description = "PostgreSQL Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "PostgreSQL DB Name")]
    postgresql_db_name: Option<String>,
    #[schemars(description = "PostgreSQL Host")]
    postgresql_host: Option<String>,
    #[schemars(description = "PostgreSQL Password")]
    postgresql_password: Option<String>,
    #[schemars(description = "PostgreSQL Port")]
    postgresql_port: Option<String>,
    #[schemars(description = "PostgreSQL Username")]
    postgresql_username: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "PostgreSQL Revocation statements")]
    revocation_statement: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerRabbitMqInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RabbitMQ Admin password")]
    rabbitmq_admin_pwd: Option<String>,
    #[schemars(description = "RabbitMQ Admin User")]
    rabbitmq_admin_user: Option<String>,
    #[schemars(description = "Server URI")]
    rabbitmq_server_uri: Option<String>,
    #[schemars(description = "User configuration permission")]
    rabbitmq_user_conf_permission: Option<String>,
    #[schemars(description = "User read permission")]
    rabbitmq_user_read_permission: Option<String>,
    #[schemars(description = "User Tags")]
    rabbitmq_user_tags: Option<String>,
    #[schemars(description = "User Virtual Host")]
    rabbitmq_user_vhost: Option<String>,
    #[schemars(description = "User write permission")]
    rabbitmq_user_write_permission: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerRdpInput {
    #[schemars(description = "AllowUserExtendSession")]
    allow_user_extend_session: Option<i64>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for fixed-user-only=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Allow access using externally (IdP) provided username [true/false]")]
    fixed_user_only: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RDP Admin Name")]
    rdp_admin_name: Option<String>,
    #[schemars(description = "RDP Admin password")]
    rdp_admin_pwd: Option<String>,
    #[schemars(description = "Hostname")]
    rdp_host_name: Option<String>,
    #[schemars(description = "Port")]
    rdp_host_port: Option<String>,
    #[schemars(description = "Groups")]
    rdp_user_groups: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "WarnBeforeUserExpiration")]
    warn_user_before_expiration: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerRedshiftInput {
    #[schemars(description = "Redshift Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "Redshift DB Name")]
    redshift_db_name: Option<String>,
    #[schemars(description = "Redshift Host")]
    redshift_host: Option<String>,
    #[schemars(description = "Redshift Password")]
    redshift_password: Option<String>,
    #[schemars(description = "Redshift Port")]
    redshift_port: Option<String>,
    #[schemars(description = "Redshift Username")]
    redshift_username: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayCreateProducerSnowflakeInput {
    #[schemars(description = "Account name")]
    account: Option<String>,
    #[schemars(description = "Database Password")]
    account_password: Option<String>,
    #[schemars(description = "Database Username")]
    account_username: Option<String>,
    #[schemars(description = "The authentication mode for the temporary user [password/key]")]
    auth_mode: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Database name")]
    db_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    key_algo: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    private_key_passphrase: Option<String>,
    #[schemars(description = "User role")]
    role: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Warehouse name")]
    warehouse: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayDeleteAllowedAccessInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Allowed access name to delete")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct DeleteGatewayAllowedAccessIdInput {
    #[schemars(description = "The access id to be stripped of access to gateway")]
    access_id: String,
    #[schemars(description = "The name of the updated cluster, e.g. acc-abcd12345678/p-123456789012/defaultCluster")]
    cluster_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayDeleteK8sAuthConfigInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S Auth config name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayDeleteMigrationInput {
    #[schemars(description = "Migration ID")]
    id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayDeleteProducerInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayDownloadCustomerFragmentsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetAllowedAccessInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Allowed access name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetCacheInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetConfigInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetDefaultsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetK8sAuthConfigInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S Auth config name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetLdapAuthConfigInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetLogForwardingInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetMigrationInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Migration name to display")]
    name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetProducerInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetTmpUsersInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayGetRemoteAccessInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayListCustomerFragmentsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayListMigrationInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayListProducersInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayListRotatedSecretsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayMigratePersonalItemsInput {
    #[schemars(description = "1Password user email to connect to the API")]
    1password_email: Option<String>,
    #[schemars(description = "1Password user password to connect to the API")]
    1password_password: Option<String>,
    #[schemars(description = "1Password user secret key to connect to the API")]
    1password_secret_key: Option<String>,
    #[schemars(description = "1Password api container url")]
    1password_url: Option<String>,
    #[schemars(description = "1Password list of vault to get the items from")]
    1password_vaults: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value")]
    protection_key: Option<String>,
    #[schemars(description = "Target location in your Akeyless personal folder for migrated secrets")]
    target_location: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Migration type for now only 1password.")]
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayStatusMigrationInput {
    #[schemars(description = "Migration ID")]
    id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Migration name to display")]
    name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayRevokeTmpUsersInput {
    #[schemars(description = "Host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Revoke All Temp Creds")]
    revoke_all: Option<bool>,
    #[schemars(description = "Soft Delete")]
    soft_delete: Option<bool>,
    #[schemars(description = "Tmp Creds ID")]
    tmp_creds_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotateSecretInput {
    rotate_all_services_boolean: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Secret name (Rotated Secret or Custom Dynamic Secret)")]
    name: String,
    #[schemars(description = "Rotate all associated services")]
    rotate_all_services: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayStartProducerInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayStopProducerInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewaySyncMigrationInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Migration name")]
    name: String,
    #[schemars(description = "true, for starting synchronization, false for stopping")]
    start_sync: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateAllowedAccessInput {
    sub_claims_case_insensitive: Option<bool>,
    #[schemars(description = "Access ID The access id to be attached to this allowed access. Auth method with this access id should already exist.")]
    access_id: String,
    #[schemars(description = "Treat sub claims as case-sensitive [true/false]")]
    case_sensitive: Option<String>,
    #[schemars(description = "Allowed access description")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Allowed access name")]
    name: String,
    #[schemars(description = "New allowed access name")]
    new_name: Option<String>,
    #[schemars(description = "Permissions  Comma-seperated list of permissions for this allowed access. Available permissions: [defaults,targets,classic_keys,automatic_migration,ldap_auth,dynamic_secret,k8s_auth,log_forwarding,zero_knowledge_encryption,rotated_secret,caching,event_forwarding,admin,kmip,general,rotate_secret_value]")]
    permissions: Option<String>,
    #[schemars(description = "Sub claims key/val of sub claims, e.g group=admins,developers")]
    sub_claims: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateCacheInput {
    #[schemars(description = "Secure backup interval in minutes. To ensure service continuity in case of power cycle and network outage secrets will be backed up periodically per backup interval")]
    backup_interval: Option<String>,
    #[schemars(description = "Enable cache [true/false]")]
    enable_cache: Option<String>,
    #[schemars(description = "Enable proactive caching [true/false]")]
    enable_proactive: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "When using Cache or/and Proactive Cache, additional secrets will be fetched upon requesting a secret, based on the requestor's access policy. Define minimum fetching interval to avoid over fetching in a given time frame")]
    minimum_fetch_interval: Option<String>,
    #[schemars(description = "Stale timeout in minutes, cache entries which are not accessed within timeout will be removed from cache")]
    stale_timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateDefaultsInput {
    #[schemars(description = "Default Certificate access id for UI login")]
    cert_access_id: Option<String>,
    #[schemars(description = "Trigger an event when Gateway status is changed [true/false]")]
    event_on_status_change: Option<String>,
    #[schemars(description = "Hvp route version to use [1/2]")]
    hvp_route_version: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the gateway default encryption key")]
    key: Option<String>,
    #[schemars(description = "Default OIDC access id for UI login")]
    oidc_access_id: Option<String>,
    #[schemars(description = "Default SAML access id for UI login")]
    saml_access_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateItemInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "API ID to rotate (relevant only for rotator-type=api-key)")]
    api_id: Option<String>,
    #[schemars(description = "API key to rotate (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "ApplicationId (used in azure)")]
    app_id: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Secret payload to be sent with rotation request (relevant only for rotator-type=custom)")]
    custom_payload: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "The email of the gcp service account to rotate")]
    gcp_service_account_email: Option<String>,
    #[schemars(description = "The key id of the gcp service account to rotate")]
    gcp_service_account_key_id: Option<String>,
    #[schemars(description = "Create a new access key without deleting the old key from AWS for backup (relevant only for AWS) [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. (relevant only for --type=rotated-secret). If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Item name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_metadata: Option<String>,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected \\\"use-self-creds\\\" at rotator-creds-type, this username will try to rotate it's own password, if \\\"use-target-creds\\\" is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Rotation Hour")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotation credentials type")]
    rotator_creds_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Item type")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateK8sAuthConfigInput {
    #[schemars(description = "The access ID of the Kubernetes auth method")]
    access_id: String,
    #[schemars(description = "Cluster access type. options: [native_k8s, rancher]")]
    cluster_api_type: Option<String>,
    #[schemars(description = "Disable issuer validation [true/false]")]
    disable_issuer_validation: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S auth type [token/certificate]. (relevant for \"native_k8s\" only)")]
    k8s_auth_type: Option<String>,
    #[schemars(description = "The CA Certificate (base64 encoded) to use to call into the kubernetes API server")]
    k8s_ca_cert: Option<String>,
    #[schemars(description = "Content of the k8 client certificate (PEM format) in a Base64 format (relevant for \"native_k8s\" only)")]
    k8s_client_certificate: Option<String>,
    #[schemars(description = "Content of the k8 client private key (PEM format) in a Base64 format (relevant for \"native_k8s\" only)")]
    k8s_client_key: Option<String>,
    #[schemars(description = "The URL of the kubernetes API server")]
    k8s_host: String,
    #[schemars(description = "The Kubernetes JWT issuer name. K8SIssuer is the claim that specifies who issued the Kubernetes token")]
    k8s_issuer: Option<String>,
    #[schemars(description = "K8S Auth config name")]
    name: String,
    #[schemars(description = "K8S Auth config new name")]
    new_name: String,
    #[schemars(description = "The api key used to access the TokenReview API to validate other JWTs (relevant for \"rancher\" only)")]
    rancher_api_key: Option<String>,
    #[schemars(description = "The cluster id as define in rancher (relevant for \"rancher\" only)")]
    rancher_cluster_id: Option<String>,
    #[schemars(description = "The private key (base64 encoded) associated with the public key defined in the Kubernetes auth")]
    signing_key: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Time in seconds of expiration of the Akeyless Kube Auth Method token")]
    token_exp: Option<i64>,
    #[schemars(description = "A Kubernetes service account JWT used to access the TokenReview API to validate other JWTs (relevant for \"native_k8s\" only). If not set, the JWT submitted in the authentication process will be used to access the Kubernetes TokenReview API.")]
    token_reviewer_jwt: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLdapAuthConfigInput {
    #[schemars(description = "The access ID of the Ldap auth method")]
    access_id: Option<String>,
    #[schemars(description = "Bind DN")]
    bind_dn: Option<String>,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: Option<String>,
    #[schemars(description = "Group Attr")]
    group_attr: Option<String>,
    #[schemars(description = "Group Dn")]
    group_dn: Option<String>,
    #[schemars(description = "Group Filter")]
    group_filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "LDAP CA Certificate (base64 encoded)")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "Enable Ldap [true/false]")]
    ldap_enable: Option<String>,
    #[schemars(description = "LDAP Server URL, e.g. ldap://planetexpress.com:389")]
    ldap_url: Option<String>,
    #[schemars(description = "The private key (base64 encoded), associated with the public key defined in the Ldap auth")]
    signing_key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Attribute")]
    user_attribute: Option<String>,
    #[schemars(description = "User DN")]
    user_dn: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingAwsS3Input {
    #[schemars(description = "AWS access id relevant for access_key auth-type")]
    access_id: Option<String>,
    #[schemars(description = "AWS access key relevant for access_key auth-type")]
    access_key: Option<String>,
    #[schemars(description = "AWS auth type [access_key/cloud_id/assume_role]")]
    auth_type: Option<String>,
    #[schemars(description = "AWS S3 bucket name")]
    bucket_name: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "AWS S3 destination folder for logs")]
    log_folder: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "AWS region")]
    region: Option<String>,
    #[schemars(description = "AWS role arn relevant for assume_role auth-type")]
    role_arn: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingAzureAnalyticsInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable batch forwarding [true/false]")]
    enable_batch: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Azure workspace id")]
    workspace_id: Option<String>,
    #[schemars(description = "Azure workspace key")]
    workspace_key: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingDatadogInput {
    #[schemars(description = "Datadog api key")]
    api_key: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Datadog host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Datadog log service")]
    log_service: Option<String>,
    #[schemars(description = "Datadog log source")]
    log_source: Option<String>,
    #[schemars(description = "A comma-separated list of Datadog log tags formatted as \"key:value\" strings")]
    log_tags: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingElasticsearchInput {
    #[schemars(description = "Elasticsearch api key relevant only for api_key auth-type")]
    api_key: Option<String>,
    #[schemars(description = "Elasticsearch auth type [api_key/password]")]
    auth_type: Option<String>,
    #[schemars(description = "Elasticsearch cloud id relevant only for cloud server-type")]
    cloud_id: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable tls")]
    enable_tls: Option<bool>,
    #[schemars(description = "Elasticsearch index")]
    index: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Elasticsearch nodes relevant only for nodes server-type")]
    nodes: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Elasticsearch password relevant only for password auth-type")]
    password: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Elasticsearch server type [cloud/nodes]")]
    server_type: Option<String>,
    #[schemars(description = "Elasticsearch tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Elasticsearch user name relevant only for password auth-type")]
    user_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingGoogleChronicleInput {
    #[schemars(description = "Google chronicle customer id")]
    customer_id: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Google chronicle log type")]
    log_type: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Google chronicle region [eu_multi_region/london/us_multi_region/singapore/tel_aviv]")]
    region: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingLogstashInput {
    #[schemars(description = "Logstash dns")]
    dns: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable tls")]
    enable_tls: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Logstash protocol [tcp/udp]")]
    protocol: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Logstash tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingLogzIoInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logz-io token")]
    logz_io_token: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "LogzIo protocol [tcp/https]")]
    protocol: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingSplunkInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable batch forwarding [true/false]")]
    enable_batch: Option<String>,
    #[schemars(description = "Enable tls")]
    enable_tls: Option<bool>,
    #[schemars(description = "Splunk index")]
    index: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Splunk source")]
    source: Option<String>,
    #[schemars(description = "Splunk source type")]
    source_type: Option<String>,
    #[schemars(description = "Splunk token")]
    splunk_token: Option<String>,
    #[schemars(description = "Splunk server URL")]
    splunk_url: Option<String>,
    #[schemars(description = "Splunk tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingStdoutInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingSumologicInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Sumologic endpoint URL")]
    endpoint: Option<String>,
    #[schemars(description = "Sumologic host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "A comma-separated list of Sumologic tags")]
    sumologic_tags: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateLogForwardingSyslogInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable tls relevant only for network type TCP")]
    enable_tls: Option<bool>,
    #[schemars(description = "Syslog formatter [text/cef]")]
    formatter: Option<String>,
    #[schemars(description = "Syslog host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Syslog network [tcp/udp]")]
    network: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Syslog target tag")]
    target_tag: Option<String>,
    #[schemars(description = "Syslog tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateMigrationInput {
    service_account_key_decoded: Option<String>,
    #[schemars(description = "Enable/Disable automatic/recurrent rotation for migrated secrets. Default is false: only manual rotation is allowed for migrated secrets. If set to true, this command should be combined with --ad-rotation-interval and --ad-rotation-hour parameters (Relevant only for Active Directory migration)")]
    ad_auto_rotate: Option<String>,
    #[schemars(description = "How many days before the expiration of discovered certificates would you like to be notified (Relevant only for Active Directory migration with certificate discovery enabled)")]
    ad_cert_expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Path location template for migrating certificates e.g.: /Certificates/{{COMMON_NAME}} (Relevant only for Active Directory migration with certificate discovery enabled)")]
    ad_certificates_path_template: Option<String>,
    #[schemars(description = "Distinguished Name of Computer objects (servers) to search in Active Directory e.g.: CN=Computers,DC=example,DC=com (Relevant only for Active Directory migration)")]
    ad_computer_base_dn: Option<String>,
    #[schemars(description = "Enable/Disable discovery of IIS application from each domain server as part of the SSH/Windows Rotated Secrets. Default is false. (Relevant only for Active Directory migration)")]
    ad_discover_iis_app: Option<String>,
    #[schemars(description = "Enable/Disable discovery of Windows services from each domain server as part of the SSH/Windows Rotated Secrets. Default is false. (Relevant only for Active Directory migration)")]
    ad_discover_services: Option<String>,
    #[schemars(description = "Set migration discovery types (domain-users, computers, local-users). (Relevant only for Active Directory migration)")]
    ad_discovery_types: Option<Vec<String>>,
    #[schemars(description = "Active Directory Domain Name (Relevant only for Active Directory migration)")]
    ad_domain_name: Option<String>,
    #[schemars(description = "Path location template for migrating domain users as Rotated Secrets e.g.: .../DomainUsers/{{USERNAME}} (Relevant only for Active Directory migration)")]
    ad_domain_users_path_template: Option<String>,
    #[schemars(description = "Comma-separated list of Local Users which should not be migrated (Relevant only for Active Directory migration)")]
    ad_local_users_ignore: Option<String>,
    #[schemars(description = "Path location template for migrating domain users as Rotated Secrets e.g.: .../LocalUsers/{{COMPUTER_NAME}}/{{USERNAME}} (Relevant only for Active Directory migration)")]
    ad_local_users_path_template: Option<String>,
    #[schemars(description = "Filter by Operating System to run the migration, can be used with wildcards, e.g. SRV20* (Relevant only for Active Directory migration)")]
    ad_os_filter: Option<String>,
    #[schemars(description = "The hour of the scheduled rotation in UTC (Relevant only for Active Directory migration)")]
    ad_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic rotation [1-365] (Relevant only for Active Directory migration)")]
    ad_rotation_interval: Option<i64>,
    #[schemars(description = "Enable/Disable RDP Secure Remote Access for the migrated local users rotated secrets. Default is false: rotated secrets will not be created with SRA (Relevant only for Active Directory migration)")]
    ad_sra_enable_rdp: Option<String>,
    #[schemars(description = "Set the SSH Port for further connection to the domain servers. Default is port 22 (Relevant only for Active Directory migration)")]
    ad_ssh_port: Option<String>,
    #[schemars(description = "Relevant only for ad-discovery-types=computers. For linked, all computers will be migrated into a linked target(s). if set with regular, the migration will create a target for each computer.")]
    ad_target_format: Option<String>,
    #[schemars(description = "Active Directory LDAP Target Name. Server type should be Active Directory (Relevant only for Active Directory migration)")]
    ad_target_name: Option<String>,
    #[schemars(description = "Path location template for migrating domain servers as SSH/Windows Targets e.g.: .../Servers/{{COMPUTER_NAME}} (Relevant only for Active Directory migration)")]
    ad_targets_path_template: Option<String>,
    #[schemars(description = "Set the target type of the domain servers [ssh/windows](Relevant only for Active Directory migration)")]
    ad_targets_type: Option<String>,
    #[schemars(description = "Distinguished Name of User objects to search in Active Directory, e.g.: CN=Users,DC=example,DC=com (Relevant only for Active Directory migration)")]
    ad_user_base_dn: Option<String>,
    #[schemars(description = "Comma-separated list of domain groups from which privileged domain users will be migrated. If empty, migrate all users based on the --ad-user-base-dn (Relevant only for Active Directory migration)")]
    ad_user_groups: Option<String>,
    #[schemars(description = "Use WinRM over HTTP, by default runs over HTTPS")]
    ad_winrm_over_http: Option<String>,
    #[schemars(description = "Set the WinRM Port for further connection to the domain servers. Default is 5986 (Relevant only for Active Directory migration)")]
    ad_winrm_port: Option<String>,
    #[schemars(description = "Enable/Disable discovery of local users from each domain server and migrate them as SSH/Windows Rotated Secrets. Default is false: only domain users will be migrated. Discovery of local users might require further installation of SSH on the servers, based on the supplied computer base DN. This will be implemented automatically as part of the migration process (Relevant only for Active Directory migration) Deprecated: use AdDiscoverTypes")]
    ad_discover_local_users: Option<String>,
    #[schemars(description = "Enable AI-assisted certificate discovery (only when AI Insight is enabled on the Gateway)")]
    ai_certificate_discovery: Option<String>,
    #[schemars(description = "AWS Secret Access Key (relevant only for AWS migration)")]
    aws_key: Option<String>,
    #[schemars(description = "AWS Access Key ID with sufficient permissions to get all secrets, e.g. 'arn:aws:secretsmanager:[Region]:[AccountId]:secret:[/path/to/secrets/*]' (relevant only for AWS migration)")]
    aws_key_id: Option<String>,
    #[schemars(description = "AWS region of the required Secrets Manager (relevant only for AWS migration)")]
    aws_region: Option<String>,
    #[schemars(description = "Azure Key Vault Access client ID, should be Azure AD App with a service principal (relevant only for Azure Key Vault migration)")]
    azure_client_id: Option<String>,
    #[schemars(description = "Azure Key Vault Name (relevant only for Azure Key Vault migration)")]
    azure_kv_name: Option<String>,
    #[schemars(description = "Azure Key Vault secret (relevant only for Azure Key Vault migration)")]
    azure_secret: Option<String>,
    #[schemars(description = "Azure Key Vault Access tenant ID (relevant only for Azure Key Vault migration)")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "Conjur account name set on your Conjur server (relevant only for Conjur migration).")]
    conjur_account: Option<String>,
    #[schemars(description = "Conjur API Key for the specified user (relevant only for Conjur migration).")]
    conjur_api_key: Option<String>,
    #[schemars(description = "Conjur server base URL (relevant only for Conjur migration). If conjur-url is HTTPS and Conjur uses a private CA/self-signed certificate, make the CA bundle available on the Gateway and set CONJUR_SSL_CERT_PATH to its path.")]
    conjur_url: Option<String>,
    #[schemars(description = "Conjur username used to authenticate (relevant only for Conjur migration).")]
    conjur_username: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Base64-encoded GCP Service Account private key text with sufficient permissions to Secrets Manager, Minimum required permission is Secret Manager Secret Accessor, e.g. 'roles/secretmanager.secretAccessor' (relevant only for GCP migration)")]
    gcp_key: Option<String>,
    #[schemars(description = "GCP Project ID (cross-project override)")]
    gcp_project_id: Option<String>,
    #[schemars(description = "Import secret key as json value or independent secrets (relevant only for HasiCorp Vault migration) [true/false]")]
    hashi_json: Option<String>,
    #[schemars(description = "HashiCorp Vault Namespaces is a comma-separated list of namespaces which need to be imported into Akeyless Vault. For every provided namespace, all its child namespaces are imported as well, e.g. nmsp/subnmsp1/subnmsp2,nmsp/anothernmsp. By default, import all namespaces (relevant only for HasiCorp Vault migration)")]
    hashi_ns: Option<Vec<String>>,
    #[schemars(description = "HashiCorp Vault access token with sufficient permissions to preform list & read operations on secrets objects (relevant only for HasiCorp Vault migration)")]
    hashi_token: Option<String>,
    #[schemars(description = "HashiCorp Vault API URL, e.g. https://vault-mgr01:8200 (relevant only for HasiCorp Vault migration)")]
    hashi_url: Option<String>,
    #[schemars(description = "A comma separated list of IPs, CIDR ranges, or DNS names to scan")]
    hosts: String,
    #[schemars(description = "Migration ID (Can be retrieved with gateway-list-migration command)")]
    id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "For Certificate Authentication method K8s Cluster CA certificate (relevant only for K8s migration with Certificate Authentication method)")]
    k8s_ca_certificate: Option<Vec<i64>>,
    #[schemars(description = "K8s Client certificate with sufficient permission to list and get secrets in the namespace(s) you selected (relevant only for K8s migration with Certificate Authentication method)")]
    k8s_client_certificate: Option<Vec<i64>>,
    #[schemars(description = "K8s Client key (relevant only for K8s migration with Certificate Authentication method)")]
    k8s_client_key: Option<Vec<i64>>,
    #[schemars(description = "K8s Namespace, Use this field to import secrets from a particular namespace only. By default, the secrets are imported from all namespaces (relevant only for K8s migration)")]
    k8s_namespace: Option<String>,
    #[schemars(description = "K8s Client password (relevant only for K8s migration with Password Authentication method)")]
    k8s_password: Option<String>,
    #[schemars(description = "K8s Skip Control Plane Secrets, This option allows to avoid importing secrets from system namespaces (relevant only for K8s migration)")]
    k8s_skip_system: Option<bool>,
    #[schemars(description = "For Token Authentication method K8s Bearer Token with sufficient permission to list and get secrets in the namespace(s) you selected (relevant only for K8s migration with Token Authentication method)")]
    k8s_token: Option<String>,
    #[schemars(description = "K8s API Server URL, e.g. https://k8s-api.mycompany.com:6443 (relevant only for K8s migration)")]
    k8s_url: Option<String>,
    #[schemars(description = "For Password Authentication method K8s Client username with sufficient permission to list and get secrets in the namespace(s) you selected (relevant only for K8s migration with Password Authentication method)")]
    k8s_username: Option<String>,
    #[schemars(description = "Migration name")]
    name: Option<String>,
    #[schemars(description = "New migration name")]
    new_name: Option<String>,
    #[schemars(description = "A comma separated list of port ranges Examples: \"80,443\" or \"80,443,8080-8090\" or \"443\"")]
    port_ranges: Option<String>,
    #[schemars(description = "The name of the key that protects the classic key value (if empty, the account default key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "Enable/Disable automatic/recurrent rotation for migrated secrets. Default is false: only manual rotation is allowed for migrated secrets. If set to true, this command should be combined with --si-rotation-interval and --si-rotation-hour parameters (Relevant only for Server Inventory migration)")]
    si_auto_rotate: Option<String>,
    #[schemars(description = "The hour of the scheduled rotation in UTC (Relevant only for Server Inventory migration)")]
    si_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic rotation [1-365] (Relevant only for Server Inventory migration)")]
    si_rotation_interval: Option<i64>,
    #[schemars(description = "Enable/Disable RDP Secure Remote Access for the migrated local users rotated secrets. Default is false: rotated secrets will not be created with SRA (Relevant only for Server Inventory migration)")]
    si_sra_enable_rdp: Option<String>,
    #[schemars(description = "SSH, Windows or Linked Target Name. (Relevant only for Server Inventory migration)")]
    si_target_name: String,
    #[schemars(description = "Comma-separated list of groups to migrate users from. If empty, all users from all groups will be migrated (Relevant only for Server Inventory migration)")]
    si_user_groups: Option<String>,
    #[schemars(description = "Comma-separated list of Local Users which should not be migrated (Relevant only for Server Inventory migration)")]
    si_users_ignore: Option<String>,
    #[schemars(description = "Path location template for migrating users as Rotated Secrets e.g.: .../Users/{{COMPUTER_NAME}}/{{USERNAME}} (Relevant only for Server Inventory migration)")]
    si_users_path_template: String,
    #[schemars(description = "Target location in Akeyless for imported secrets")]
    target_location: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerArtifactoryInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: Option<String>,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: Option<String>,
    #[schemars(description = "Token Audience")]
    artifactory_token_audience: String,
    #[schemars(description = "Token Scope")]
    artifactory_token_scope: String,
    #[schemars(description = "Base URL")]
    base_url: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerAwsInput {
    access_mode: Option<String>,
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Access Key ID")]
    aws_access_key_id: Option<String>,
    #[schemars(description = "Secret Access Key")]
    aws_access_secret_key: Option<String>,
    #[schemars(description = "The AWS External ID associated with the AWS role (relevant only for assume_role mode)")]
    aws_external_id: Option<String>,
    #[schemars(description = "AWS Role ARNs to be used in the Assume Role operation (relevant only for assume_role mode)")]
    aws_role_arns: Option<String>,
    #[schemars(description = "AWS User console access")]
    aws_user_console_access: Option<bool>,
    #[schemars(description = "AWS User groups")]
    aws_user_groups: Option<String>,
    #[schemars(description = "AWS User policies")]
    aws_user_policies: Option<String>,
    #[schemars(description = "Enable AWS User programmatic access")]
    aws_user_programmatic_access: Option<bool>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Region")]
    region: Option<String>,
    #[schemars(description = "The AWS account id")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "String of Key value session tags comma separated, relevant only for Assumed Role")]
    session_tags: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "String of transitive tag keys space separated, relevant only for Assumed Role")]
    transitive_tag_keys: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerAzureInput {
    #[schemars(description = "Azure App Object Id")]
    app_obj_id: Option<String>,
    #[schemars(description = "Azure AD administrative unit (relevant only when azure-user-portal-access=true)")]
    azure_administrative_unit: Option<String>,
    #[schemars(description = "Azure Client ID")]
    azure_client_id: Option<String>,
    #[schemars(description = "Azure Client Secret")]
    azure_client_secret: Option<String>,
    #[schemars(description = "Azure Tenant ID")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "FixedUserClaimKeyname")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Fixed user")]
    fixed_user_only: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic secret encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Group Object Id")]
    user_group_obj_id: Option<String>,
    #[schemars(description = "Azure User portal access")]
    user_portal_access: Option<bool>,
    #[schemars(description = "User Principal Name")]
    user_principal_name: Option<String>,
    #[schemars(description = "Azure User programmatic access")]
    user_programmatic_access: Option<bool>,
    #[schemars(description = "User Role Template Id")]
    user_role_template_id: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerCassandraInput {
    #[schemars(description = "Cassandra creation statements")]
    cassandra_creation_statements: Option<String>,
    #[schemars(description = "Cassandra hosts IP or addresses, comma separated")]
    cassandra_hosts: Option<String>,
    #[schemars(description = "Cassandra superuser password")]
    cassandra_password: Option<String>,
    #[schemars(description = "Cassandra port")]
    cassandra_port: Option<String>,
    #[schemars(description = "Cassandra superuser username")]
    cassandra_username: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerVenafiInput {
    #[schemars(description = "Admin credentials rotation interval (days)")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "Allow subdomains")]
    allow_subdomains: Option<bool>,
    #[schemars(description = "Allowed domains")]
    allowed_domains: Option<Vec<String>>,
    #[schemars(description = "Auto generated folder")]
    auto_generated_folder: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Automatic admin credentials rotation")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Root first in chain")]
    root_first_in_chain: Option<bool>,
    #[schemars(description = "Use Akeyless PKI issuer or Venafi issuer")]
    sign_using_akeyless_pki: Option<bool>,
    #[schemars(description = "Signer key name")]
    signer_key_name: Option<String>,
    #[schemars(description = "Store private key")]
    store_private_key: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL in time.Duration format (2160h / 129600m / etc...). When using sign-using-akeyless-pki certificates created will have this validity period, otherwise the user-ttl is taken from the Validity Period field of the Zone's' Issuing Template. When using cert-manager it is advised to have a TTL of above 60 days (1440h). For more information - https://cert-manager.io/docs/usage/certificate/")]
    user_ttl: Option<String>,
    #[schemars(description = "Venafi Access Token to use to access the TPP environment (Relevant when using TPP)")]
    venafi_access_token: Option<String>,
    #[schemars(description = "Venafi API key")]
    venafi_api_key: Option<String>,
    #[schemars(description = "Venafi Baseurl")]
    venafi_baseurl: Option<String>,
    #[schemars(description = "Venafi Client ID that was used when the access token was generated")]
    venafi_client_id: Option<String>,
    #[schemars(description = "Venafi Refresh Token to use when the Access Token is expired (Relevant when using TPP)")]
    venafi_refresh_token: Option<String>,
    #[schemars(description = "Venafi using TPP")]
    venafi_use_tpp: Option<bool>,
    #[schemars(description = "Venafi Zone")]
    venafi_zone: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerChefInput {
    #[schemars(description = "Organizations")]
    chef_orgs: Option<String>,
    #[schemars(description = "Server key")]
    chef_server_key: Option<String>,
    #[schemars(description = "Server URL")]
    chef_server_url: Option<String>,
    #[schemars(description = "Server username")]
    chef_server_username: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Skip SSL")]
    skip_ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerCustomInput {
    #[schemars(description = "Define rotation interval in days")]
    admin_rotation_interval_days: Option<i64>,
    #[schemars(description = "URL of an endpoint that implements /sync/create method, for example https://webhook.example.com/sync/create")]
    create_sync_url: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Should admin credentials be rotated")]
    enable_admin_rotation: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Secret payload to be sent with each create/revoke webhook request")]
    payload: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "URL of an endpoint that implements /sync/revoke method, for example https://webhook.example.com/sync/revoke")]
    revoke_sync_url: String,
    #[schemars(description = "URL of an endpoint that implements /sync/rotate method, for example https://webhook.example.com/sync/rotate")]
    rotate_sync_url: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Maximum allowed time in seconds for the webhook to return the results")]
    timeout_sec: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerDockerhubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "DockerhubPassword is either the user's password access token to manage the repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Access token scopes list (comma-separated) to give the dynamic secret valid options are in \"repo:admin\", \"repo:write\", \"repo:read\", \"repo:public_read\"")]
    dockerhub_token_scopes: Option<String>,
    #[schemars(description = "DockerhubUsername is the name of the user in dockerhub")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerEksInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: Option<String>,
    #[schemars(description = "IAM assume role")]
    eks_assume_role: Option<String>,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: Option<String>,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: Option<String>,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: Option<String>,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerGcpInput {
    access_type: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (Relevant only when --access-type=external)")]
    fixed_user_claim_keyname: Option<String>,
    gcp_cred_type: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Service account key algorithm, e.g. KEY_ALG_RSA_1024 (Relevant only when --access-type=sa and --gcp-cred-type=key)")]
    gcp_key_algo: Option<String>,
    #[schemars(description = "GCP Project ID override for dynamic secret operations")]
    gcp_project_id: Option<String>,
    #[schemars(description = "The email of the fixed service account to generate keys or tokens for (Relevant only when --access-type=sa and --service-account-type=fixed)")]
    gcp_sa_email: Option<String>,
    #[schemars(description = "Access token scopes list, e.g. scope1,scope2 (Relevant only when --access-type=sa; required when --gcp-cred-type=token)")]
    gcp_token_scopes: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Role binding definitions in JSON format (Relevant only when --access-type=sa and --service-account-type=dynamic)")]
    role_binding: Option<String>,
    #[schemars(description = "Comma-separated list of GCP roles to assign to the user (Relevant only when --access-type=external)")]
    role_names: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "The type of the GCP service account. Options [fixed, dynamic] (Relevant only when --access-type=sa)")]
    service_account_type: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerGithubInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "GitHub application installation id")]
    installation_id: Option<i64>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub organization name")]
    installation_organization: Option<String>,
    #[schemars(description = "Optional, mutually exclusive with installation id, GitHub repository '<owner>/<repo-name>'")]
    installation_repository: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Optional - installation token's allowed permissions")]
    token_permissions: Option<Vec<String>>,
    #[schemars(description = "Optional - installation token's allowed repositories")]
    token_repositories: Option<Vec<String>>,
    #[schemars(description = "Token TTL")]
    token_ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerGkeInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerHanaDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "HanaDb Name")]
    hana_dbname: Option<String>,
    #[schemars(description = "HanaDb Creation statements")]
    hanadb_create_statements: Option<String>,
    #[schemars(description = "HanaDb Host")]
    hanadb_host: Option<String>,
    #[schemars(description = "HanaDb Password")]
    hanadb_password: Option<String>,
    #[schemars(description = "HanaDb Port")]
    hanadb_port: Option<String>,
    #[schemars(description = "HanaDb Revocation statements")]
    hanadb_revocation_statements: Option<String>,
    #[schemars(description = "HanaDb Username")]
    hanadb_username: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerNativeK8sInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Comma-separated list of allowed K8S namespaces for the generated ServiceAccount (relevant only for k8s-service-account-type=dynamic)")]
    k8s_allowed_namespaces: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "K8S Namespace where the ServiceAccount exists.")]
    k8s_namespace: Option<String>,
    #[schemars(description = "The pre-existing Role or ClusterRole name to bind the generated ServiceAccount to (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_name: Option<String>,
    #[schemars(description = "Specifies the type of the pre-existing K8S role [Role, ClusterRole] (relevant only for k8s-service-account-type=dynamic)")]
    k8s_predefined_role_type: Option<String>,
    #[schemars(description = "Content of the yaml in a Base64 format.")]
    k8s_rolebinding_yaml_data: Option<String>,
    #[schemars(description = "Path to yaml file that contains definitions of K8S role and role binding (relevant only for k8s-service-account-type=dynamic)")]
    k8s_rolebinding_yaml_def: Option<String>,
    #[schemars(description = "K8S ServiceAccount to extract token from.")]
    k8s_service_account: Option<String>,
    #[schemars(description = "K8S ServiceAccount type [fixed, dynamic].")]
    k8s_service_account_type: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The K8s dashboard url")]
    secure_access_dashboard_url: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerLdapInput {
    provider_type: Option<String>,
    #[schemars(description = "Bind DN")]
    bind_dn: Option<String>,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Externally provided username [true/false]")]
    external_username: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for external-username=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Group DN which the temporary user should be added")]
    group_dn: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User Attribute")]
    user_attribute: Option<String>,
    #[schemars(description = "User DN")]
    user_dn: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerMongoInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB custom data")]
    mongodb_custom_data: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server host and port")]
    mongodb_host_port: Option<String>,
    #[schemars(description = "MongoDB Name")]
    mongodb_name: Option<String>,
    #[schemars(description = "MongoDB server password. You will prompted to provide a password if it will not appear in CLI parameters")]
    mongodb_password: Option<String>,
    #[schemars(description = "MongoDB Roles")]
    mongodb_roles: Option<String>,
    #[schemars(description = "MongoDB Scopes (Atlas only)")]
    mongodb_scopes: Option<String>,
    #[schemars(description = "MongoDB server URI")]
    mongodb_server_uri: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "MongoDB server username")]
    mongodb_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Encrypt producer with following key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerMssqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "CSV of allowed DB names for runtime selection when getting the secret value. Empty => use target DB only; \"*\" => any DB allowed; One or more names => user must choose from this list")]
    mssql_allowed_db_names: Option<String>,
    #[schemars(description = "MSSQL Creation statements")]
    mssql_create_statements: Option<String>,
    #[schemars(description = "MSSQL Name")]
    mssql_dbname: Option<String>,
    #[schemars(description = "MSSQL Host")]
    mssql_host: Option<String>,
    #[schemars(description = "MSSQL Password")]
    mssql_password: Option<String>,
    #[schemars(description = "MSSQL Port")]
    mssql_port: Option<String>,
    #[schemars(description = "MSSQL Revocation statements")]
    mssql_revocation_statements: Option<String>,
    #[schemars(description = "MSSQL Username")]
    mssql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerMySqlInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "MySQL DB Name")]
    mysql_dbname: Option<String>,
    #[schemars(description = "MySQL Host")]
    mysql_host: Option<String>,
    #[schemars(description = "MySQL Password")]
    mysql_password: Option<String>,
    #[schemars(description = "MySQL Port")]
    mysql_port: Option<String>,
    #[schemars(description = "MySQL Revocation statements")]
    mysql_revocation_statements: Option<String>,
    #[schemars(description = "MySQL Creation statements")]
    mysql_screation_statements: Option<String>,
    #[schemars(description = "MySQL Username")]
    mysql_username: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerOracleDbInput {
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Oracle Host")]
    oracle_host: Option<String>,
    #[schemars(description = "Oracle Password")]
    oracle_password: Option<String>,
    #[schemars(description = "Oracle Port")]
    oracle_port: Option<String>,
    #[schemars(description = "Oracle Revocation statements")]
    oracle_revocation_statements: Option<String>,
    #[schemars(description = "Oracle Creation statements")]
    oracle_screation_statements: Option<String>,
    #[schemars(description = "Oracle DB Name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Username")]
    oracle_username: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerPingInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret New name")]
    new_name: Option<String>,
    #[schemars(description = "Ping Federate administrative port")]
    ping_administrative_port: Option<String>,
    #[schemars(description = "Set a specific Access Token Management (ATM) instance for the created OAuth Client by providing the ATM Id. If no explicit value is given, the default pingfederate server ATM will be set.")]
    ping_atm_id: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    ping_authorization_port: Option<String>,
    #[schemars(description = "The subject DN of the client certificate. If no explicit value is given, the producer will create CA certificate and matched client certificate and return it as value. Used in conjunction with ping-issuer-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_cert_subject_dn: Option<String>,
    #[schemars(description = "OAuth Client Authentication Type [CLIENT_SECRET, PRIVATE_KEY_JWT, CLIENT_TLS_CERTIFICATE]")]
    ping_client_authentication_type: Option<String>,
    #[schemars(description = "Determines whether PingFederate requires a unique signed JWT from the client for each action (relevant for PRIVATE_KEY_JWT authentication method) [true/false]")]
    ping_enforce_replay_prevention: Option<String>,
    #[schemars(description = "List of OAuth client grant types [IMPLICIT, AUTHORIZATION_CODE, CLIENT_CREDENTIALS, TOKEN_EXCHANGE, REFRESH_TOKEN, ASSERTION_GRANTS, PASSWORD, RESOURCE_OWNER_CREDENTIALS]. If no explicit value is given, AUTHORIZATION_CODE will be selected as default.")]
    ping_grant_types: Option<Vec<String>>,
    #[schemars(description = "Issuer DN of trusted CA certificate that imported into Ping Federate server. You may select \\\"Trust Any\\\" to trust all the existing issuers in Ping Federate server. Used in conjunction with ping-cert-subject-dn (relevant for CLIENT_TLS_CERTIFICATE authentication method)")]
    ping_issuer_dn: Option<String>,
    #[schemars(description = "Base64-encoded JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT (Sign Algo: RS256) and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks: Option<String>,
    #[schemars(description = "The URL of the JSON Web Key Set (JWKS). If no explicit value is given, the producer will create JWKs and matched signed JWT and return it as value (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_jwks_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user password")]
    ping_password: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    ping_privileged_user: Option<String>,
    #[schemars(description = "List of URIs to which the OAuth authorization server may redirect the resource owner's user agent after authorization is obtained. At least one redirection URI is required for the AUTHORIZATION_CODE and IMPLICIT grant types.")]
    ping_redirect_uris: Option<Vec<String>>,
    #[schemars(description = "Limit the OAuth client to specific scopes list")]
    ping_restricted_scopes: Option<Vec<String>>,
    #[schemars(description = "The signing algorithm that the client must use to sign its request objects [RS256,RS384,RS512,ES256,ES384,ES512,PS256,PS384,PS512] If no explicit value is given, the client can use any of the supported signing algorithms (relevant for PRIVATE_KEY_JWT authentication method)")]
    ping_signing_algo: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The time from dynamic secret creation to expiration.")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerPostgreSqlInput {
    #[schemars(description = "PostgreSQL Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "PostgreSQL DB Name")]
    postgresql_db_name: Option<String>,
    #[schemars(description = "PostgreSQL Host")]
    postgresql_host: Option<String>,
    #[schemars(description = "PostgreSQL Password")]
    postgresql_password: Option<String>,
    #[schemars(description = "PostgreSQL Port")]
    postgresql_port: Option<String>,
    #[schemars(description = "PostgreSQL Username")]
    postgresql_username: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "PostgreSQL Revocation statements")]
    revocation_statement: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerRabbitMqInput {
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RabbitMQ Admin password")]
    rabbitmq_admin_pwd: Option<String>,
    #[schemars(description = "RabbitMQ Admin User")]
    rabbitmq_admin_user: Option<String>,
    #[schemars(description = "Server URI")]
    rabbitmq_server_uri: Option<String>,
    #[schemars(description = "User configuration permission")]
    rabbitmq_user_conf_permission: Option<String>,
    #[schemars(description = "User read permission")]
    rabbitmq_user_read_permission: Option<String>,
    #[schemars(description = "User Tags")]
    rabbitmq_user_tags: Option<String>,
    #[schemars(description = "User Virtual Host")]
    rabbitmq_user_vhost: Option<String>,
    #[schemars(description = "User write permission")]
    rabbitmq_user_write_permission: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerRdpInput {
    #[schemars(description = "AllowUserExtendSession")]
    allow_user_extend_session: Option<i64>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for fixed-user-only=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Allow access using externally (IdP) provided username [true/false]")]
    fixed_user_only: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "RDP Admin Name")]
    rdp_admin_name: Option<String>,
    #[schemars(description = "RDP Admin password")]
    rdp_admin_pwd: Option<String>,
    #[schemars(description = "Hostname")]
    rdp_host_name: Option<String>,
    #[schemars(description = "Port")]
    rdp_host_port: Option<String>,
    #[schemars(description = "Groups")]
    rdp_user_groups: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The delay duration, in seconds, to wait after generating just-in-time credentials. Accepted range: 0-120 seconds")]
    secure_access_delay: Option<i64>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "WarnBeforeUserExpiration")]
    warn_user_before_expiration: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerRedisInput {
    #[schemars(description = "A JSON array list of redis ACL rules to attach to the created user. For available rules see the ACL CAT command https://redis.io/commands/acl-cat By default the user will have permissions to read all keys '[\"~*\", \"+@read\"]'")]
    acl_rules: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Redis Host")]
    host: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "Redis Password")]
    password: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Redis Port")]
    port: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key_name: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Redis Username")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerRedshiftInput {
    #[schemars(description = "Redshift Creation statements")]
    creation_statements: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Dynamic producer encryption key")]
    producer_encryption_key: Option<String>,
    #[schemars(description = "Redshift DB Name")]
    redshift_db_name: Option<String>,
    #[schemars(description = "Redshift Host")]
    redshift_host: Option<String>,
    #[schemars(description = "Redshift Password")]
    redshift_password: Option<String>,
    #[schemars(description = "Redshift Port")]
    redshift_port: Option<String>,
    #[schemars(description = "Redshift Username")]
    redshift_username: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target DB servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateProducerSnowflakeInput {
    #[schemars(description = "Account name")]
    account: Option<String>,
    #[schemars(description = "Database Password")]
    account_password: Option<String>,
    #[schemars(description = "Database Username")]
    account_username: Option<String>,
    #[schemars(description = "The authentication mode for the temporary user [password/key]")]
    auth_mode: Option<String>,
    #[schemars(description = "Customize how temporary usernames are generated using go template")]
    custom_username_template: Option<String>,
    #[schemars(description = "Database name")]
    db_name: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    key_algo: Option<String>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Dynamic secret name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    private_key_passphrase: Option<String>,
    #[schemars(description = "User role")]
    role: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "Target name")]
    target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "User TTL")]
    user_ttl: Option<String>,
    #[schemars(description = "Warehouse name")]
    warehouse: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateTmpUsersInput {
    #[schemars(description = "Host")]
    host: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "New TTL in Minutes")]
    new_ttl_min: i64,
    #[schemars(description = "Tmp Creds ID")]
    tmp_creds_id: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateRemoteAccessInput {
    #[schemars(description = "Specify a valid SSH-URL to tunnel to SSH session")]
    allowed_ssh_url: Option<String>,
    #[schemars(description = "List of valid URLs to redirect from the Portal back to the remote access server (in a comma-delimited list)")]
    allowed_urls: Option<String>,
    #[schemars(description = "Default session TTL in minutes")]
    default_session_ttl_minutes: Option<String>,
    #[schemars(description = "Specifies whether to show/hide if the session is currently recorded [true/false]")]
    hide_session_recording: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Decide which algorithm will be used as part of the SSH initial hand-shake process")]
    kexalgs: Option<String>,
    #[schemars(description = "Enable support for additional keyboard layouts")]
    keyboard_layout: Option<String>,
    #[schemars(description = "Signs SSH certificates using legacy ssh-rsa-cert-01@openssh.com signing algorithm [true/false]")]
    legacy_ssh_algorithm: Option<String>,
    #[schemars(description = "Specify the usernameSubClaim that exists inside the IDP JWT, e.g. email")]
    rdp_target_configuration: Option<String>,
    #[schemars(description = "Specify the usernameSubClaim that exists inside the IDP JWT, e.g. email")]
    ssh_target_configuration: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateRemoteAccessDesktopAppInput {
    desktop_app_secure_web_access_url: Option<String>,
    desktop_app_secure_web_proxy: Option<String>,
    desktop_app_ssh_cert_issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateRemoteAccessRdpRecordingsInput {
    #[schemars(description = "AWS access key id. For more information refer to https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html")]
    aws_storage_access_key_id: Option<String>,
    #[schemars(description = "The AWS bucket name. For more information refer to https://docs.aws.amazon.com/s3/")]
    aws_storage_bucket_name: Option<String>,
    #[schemars(description = "The folder name in S3 bucket. For more information refer to https://docs.aws.amazon.com/s3/")]
    aws_storage_bucket_prefix: Option<String>,
    #[schemars(description = "The region where the storage is located")]
    aws_storage_region: Option<String>,
    #[schemars(description = "AWS secret access key. For more information refer to https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html")]
    aws_storage_secret_access_key: Option<String>,
    #[schemars(description = "Azure account name. For more information refer to https://learn.microsoft.com/en-us/azure/storage/common/storage-account-overview")]
    azure_storage_account_name: Option<String>,
    #[schemars(description = "Azure client id. For more information refer to https://learn.microsoft.com/en-us/azure/storage/common/storage-account-get-info?tabs=portal")]
    azure_storage_client_id: Option<String>,
    #[schemars(description = "Azure client secret. For more information refer to https://learn.microsoft.com/en-us/azure/storage/common/storage-account-get-info?tabs=portal")]
    azure_storage_client_secret: Option<String>,
    #[schemars(description = "Azure container name. For more information refer to https://learn.microsoft.com/en-us/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata")]
    azure_storage_container_name: Option<String>,
    #[schemars(description = "Azure tenant id. For more information refer to https://learn.microsoft.com/en-us/entra/fundamentals/how-to-find-tenant")]
    azure_storage_tenant_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Enable recording of rdp session [true/false]")]
    rdp_session_recording: Option<String>,
    #[schemars(description = "Whether to compress recording files before upload")]
    rdp_session_recording_compress: Option<bool>,
    #[schemars(description = "If provided, this key will be used to encrypt uploaded recordings.")]
    rdp_session_recording_encryption_key: Option<String>,
    #[schemars(description = "RDP session recording quality [low/medium/high]")]
    rdp_session_recording_quality: Option<String>,
    #[schemars(description = "Rdp session recording storage destination [local/aws/azure]")]
    rdp_session_storage: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsAwsS3Input {
    #[schemars(description = "AWS access id relevant for access_key auth-type")]
    access_id: Option<String>,
    #[schemars(description = "AWS access key relevant for access_key auth-type")]
    access_key: Option<String>,
    #[schemars(description = "AWS auth type [access_key/cloud_id/assume_role]")]
    auth_type: Option<String>,
    #[schemars(description = "AWS S3 bucket name")]
    bucket_name: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "AWS S3 destination folder for logs")]
    log_folder: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "AWS region")]
    region: Option<String>,
    #[schemars(description = "AWS role arn relevant for assume_role auth-type")]
    role_arn: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsAzureAnalyticsInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable batch forwarding [true/false]")]
    enable_batch: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Azure workspace id")]
    workspace_id: Option<String>,
    #[schemars(description = "Azure workspace key")]
    workspace_key: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsDatadogInput {
    #[schemars(description = "Datadog api key")]
    api_key: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Datadog host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Datadog log service")]
    log_service: Option<String>,
    #[schemars(description = "Datadog log source")]
    log_source: Option<String>,
    #[schemars(description = "A comma-separated list of Datadog log tags formatted as \"key:value\" strings")]
    log_tags: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsElasticsearchInput {
    #[schemars(description = "Elasticsearch api key relevant only for api_key auth-type")]
    api_key: Option<String>,
    #[schemars(description = "Elasticsearch auth type [api_key/password]")]
    auth_type: Option<String>,
    #[schemars(description = "Elasticsearch cloud id relevant only for cloud server-type")]
    cloud_id: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable tls")]
    enable_tls: Option<bool>,
    #[schemars(description = "Elasticsearch index")]
    index: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Elasticsearch nodes relevant only for nodes server-type")]
    nodes: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Elasticsearch password relevant only for password auth-type")]
    password: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Elasticsearch server type [cloud/nodes]")]
    server_type: Option<String>,
    #[schemars(description = "Elasticsearch tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Elasticsearch user name relevant only for password auth-type")]
    user_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsGoogleChronicleInput {
    #[schemars(description = "Google chronicle customer id")]
    customer_id: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Google chronicle log type")]
    log_type: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Google chronicle region [eu_multi_region/london/us_multi_region/singapore/tel_aviv]")]
    region: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsLogstashInput {
    #[schemars(description = "Logstash dns")]
    dns: Option<String>,
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable tls")]
    enable_tls: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Logstash protocol [tcp/udp]")]
    protocol: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Logstash tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsLogzIoInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logz-io token")]
    logz_io_token: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "LogzIo protocol [tcp/https]")]
    protocol: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsSplunkInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable batch forwarding [true/false]")]
    enable_batch: Option<String>,
    #[schemars(description = "Enable tls")]
    enable_tls: Option<bool>,
    #[schemars(description = "Splunk index")]
    index: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Splunk source")]
    source: Option<String>,
    #[schemars(description = "Splunk source type")]
    source_type: Option<String>,
    #[schemars(description = "Splunk token")]
    splunk_token: Option<String>,
    #[schemars(description = "Splunk server URL")]
    splunk_url: Option<String>,
    #[schemars(description = "Splunk tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsStdoutInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsSumologicInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Sumologic endpoint URL")]
    endpoint: Option<String>,
    #[schemars(description = "Sumologic host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "A comma-separated list of Sumologic tags")]
    sumologic_tags: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GwUpdateRemoteAccessSessionLogsSyslogInput {
    #[schemars(description = "Enable Log Forwarding [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Enable tls relevant only for network type TCP")]
    enable_tls: Option<bool>,
    #[schemars(description = "Syslog formatter [text/cef]")]
    formatter: Option<String>,
    #[schemars(description = "Syslog host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Syslog network [tcp/udp]")]
    network: Option<String>,
    #[schemars(description = "Logs format [text/json]")]
    output_format: Option<String>,
    #[schemars(description = "Pull interval in seconds")]
    pull_interval: Option<String>,
    #[schemars(description = "Syslog target tag")]
    target_tag: Option<String>,
    #[schemars(description = "Syslog tls certificate")]
    tls_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GatewayUpdateTlsCertInput {
    #[schemars(description = "TLS Certificate (base64 encoded)")]
    cert_data: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "TLS Private Key (base64 encoded)")]
    key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GenerateAcmeEabInput {
    #[schemars(description = "The name of the PKI certificate issuer")]
    cert_issuer_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GenerateCaInput {
    alg: Option<String>,
    #[schemars(description = "A list of the allowed domains that clients can request to be included in the certificate (in a comma-delimited list)")]
    allowed_domains: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "A comma sepereted list of extended key usage for the intermediate (serverauth / clientauth / codesigning)")]
    extended_key_usage: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    key_type: Option<String>,
    #[schemars(description = "The maximum number of intermediate certificates that can appear in a certification path")]
    max_path_len: Option<i64>,
    #[schemars(description = "PKI chain name")]
    pki_chain_name: String,
    #[schemars(description = "The name of a key that used to encrypt the secrets values (if empty, the account default protectionKey key will be used)")]
    protection_key_name: Option<String>,
    #[schemars(description = "The number of fragments that the item will be split into")]
    split_level: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The maximum requested Time To Live for issued certificate by default in seconds, supported formats are s,m,h,d")]
    ttl: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GenerateCsrInput {
    alg: Option<String>,
    #[schemars(description = "A comma-separated list of dns alternative names")]
    alt_names: Option<String>,
    #[schemars(description = "The certificate type to be included in the CSR certificate (ssl-client/ssl-server/certificate-signing)")]
    certificate_type: Option<String>,
    #[schemars(description = "The city to be included in the CSR certificate")]
    city: Option<String>,
    #[schemars(description = "The common name to be included in the CSR certificate")]
    common_name: String,
    #[schemars(description = "The country to be included in the CSR certificate")]
    country: Option<String>,
    #[schemars(description = "Add critical to the key usage extension (will be false if not added)")]
    critical: Option<bool>,
    #[schemars(description = "The department to be included in the CSR certificate")]
    dep: Option<String>,
    #[schemars(description = "A comma-separated list of email addresses alternative names")]
    email_addresses: Option<String>,
    #[schemars(description = "The flag to indicate if the private key should be exported")]
    export_private_key: Option<bool>,
    #[schemars(description = "Generate a new classic key for the csr")]
    generate_key: Option<bool>,
    #[schemars(description = "Specifies the hash algorithm used for the encryption key's operations, available options: SHA256, SHA384, SHA512")]
    hash_algorithm: Option<String>,
    #[schemars(description = "A comma-separated list of ip addresses alternative names")]
    ip_addresses: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The type of the key to generate (classic-key/dfc)")]
    key_type: String,
    #[schemars(description = "The key name")]
    name: String,
    #[schemars(description = "The organization to be included in the CSR certificate")]
    org: Option<String>,
    #[schemars(description = "The number of fragments that the item will be split into (not includes customer fragment)")]
    split_level: Option<i64>,
    #[schemars(description = "The state to be included in the CSR certificate")]
    state: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A comma-separated list of uri alternative names")]
    uri_sans: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetAccountSettingsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetAnalyticsDataInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetAuthMethodInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetCertChallengeInput {
    #[schemars(description = "Access ID")]
    access_id: Option<String>,
    #[schemars(description = "Certificate data encoded in base64. Used if file was not provided.")]
    cert_data: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetCertificateValueInput {
    #[schemars(description = "The parent PKI Certificate Issuer's name of the certificate, required when used with display-id and token")]
    cert_issuer_name: Option<String>,
    #[schemars(description = "Certificate display ID")]
    display_id: Option<String>,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Token for getting the issued certificate")]
    issuance_token: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Certificate name")]
    name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Certificate version")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetDynamicSecretValueInput {
    #[schemars(description = "Optional arguments as key=value pairs or JSON strings, e.g - \\\"--args=csr=base64_encoded_csr --args=common_name=bar\\\" or args='{\\\"csr\\\":\\\"base64_encoded_csr\\\"}. It is possible to combine both formats.'")]
    args: Option<Vec<String>>,
    #[schemars(description = "DBName: Optional override DB name (works only if DS allows it. only relevant for MSSQL)")]
    dbname: Option<String>,
    #[schemars(description = "Host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Dynamic secret name")]
    name: String,
    #[schemars(description = "Target Name")]
    target: Option<String>,
    #[schemars(description = "Timeout in seconds")]
    timeout: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetEventForwarderInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetGroupInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Group name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetKubeExecCredsInput {
    #[schemars(description = "The Subject Alternative Names to be included in the PKI certificate (in a comma-separated list) (if CSR is supplied this flag is ignored and any DNS.* names are taken from it)")]
    alt_names: Option<String>,
    #[schemars(description = "Client authentication API version")]
    api_version: Option<String>,
    #[schemars(description = "The name of the PKI certificate issuer")]
    cert_issuer_name: String,
    #[schemars(description = "The common name to be included in the PKI certificate (if CSR is supplied this flag is ignored and the CSR subject CN is taken)")]
    common_name: Option<String>,
    #[schemars(description = "Certificate Signing Request contents encoded in base64 to generate the certificate with")]
    csr_data_base64: Option<String>,
    #[schemars(description = "A comma-separated list of extended key usage requests which will be used for certificate issuance. Supported values: 'clientauth', 'serverauth', 'codesigning'. If critical is present the extension will be marked as critical")]
    extended_key_usage: Option<String>,
    #[schemars(description = "A json string that defines the requested extra extensions for the certificate")]
    extra_extensions: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "PKI key file contents. If this option is used, the certificate will be printed to stdout")]
    key_data_base64: Option<String>,
    #[schemars(description = "The maximum path length for the generated certificate. -1, means unlimited unless the signing certificate has a maximum path length set")]
    max_path_len: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Updated certificate lifetime in seconds (must be less than the Certificate Issuer default TTL)")]
    ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The URI Subject Alternative Names to be included in the PKI certificate (in a comma-separated list) (if CSR is supplied this flag is ignored and any URI.* names are taken from it)")]
    uri_sans: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetPkiCertificateInput {
    #[schemars(description = "The Subject Alternative Names to be included in the PKI certificate (in a comma-separated list) (if CSR is supplied this flag is ignored and any DNS.* names are taken from it)")]
    alt_names: Option<String>,
    #[schemars(description = "The name of the PKI certificate issuer")]
    cert_issuer_name: String,
    #[schemars(description = "The common name to be included in the PKI certificate (if CSR is supplied this flag is ignored and the CSR subject CN is taken)")]
    common_name: Option<String>,
    #[schemars(description = "Certificate Signing Request contents encoded in base64 to generate the certificate with")]
    csr_data_base64: Option<String>,
    #[schemars(description = "A comma-separated list of extended key usage requests which will be used for certificate issuance. Supported values: 'clientauth', 'serverauth', 'codesigning'. If critical is present the extension will be marked as critical")]
    extended_key_usage: Option<String>,
    #[schemars(description = "A json string that defines the requested extra extensions for the certificate")]
    extra_extensions: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "PKI key file contents. If this option is used, the certificate will be printed to stdout")]
    key_data_base64: Option<String>,
    #[schemars(description = "The maximum path length for the generated certificate. -1, means unlimited unless the signing certificate has a maximum path length set")]
    max_path_len: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Updated certificate lifetime in seconds (must be less than the Certificate Issuer default TTL)")]
    ttl: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The URI Subject Alternative Names to be included in the PKI certificate (in a comma-separated list) (if CSR is supplied this flag is ignored and any URI.* names are taken from it)")]
    uri_sans: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetRoleInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Role name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetRotatedSecretValueInput {
    #[schemars(description = "Get rotated secret value of specific Host (relevant only for Linked Target)")]
    host: Option<String>,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Secret name")]
    names: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Secret version")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetRsaPublicInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Name of RSA key to extract the public key from")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetSecretValueInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Secret name")]
    names: Vec<String>,
    #[schemars(description = "Print the secret value with json-pretty-print (not relevent to SDK)")]
    pretty_print: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Secret version, if negative value N is provided the last N versions will return (maximum 20)")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetSshCertificateInput {
    #[schemars(description = "The name of the SSH certificate issuer")]
    cert_issuer_name: String,
    #[schemars(description = "The username to sign in the SSH certificate")]
    cert_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Set this option to output legacy ('ssh-rsa-cert-v01@openssh.com') signing algorithm name in the certificate.")]
    legacy_signing_alg_name: Option<bool>,
    #[schemars(description = "SSH public key file contents. If this option is used, the certificate will be printed to stdout")]
    public_key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Updated certificate lifetime in seconds (must be less than the Certificate Issuer default TTL)")]
    ttl: Option<i64>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetTagsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Item name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetTargetInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Include all target versions in reply")]
    show_versions: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetTargetDetailsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Include all target versions in reply")]
    show_versions: Option<bool>,
    #[schemars(description = "Target version")]
    target_version: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct HmacInput {
    #[schemars(description = "The display id of the key to use in the encryption process")]
    display_id: Option<String>,
    #[schemars(description = "Hash function [sha-256,sha-512]")]
    hash_function: Option<String>,
    #[schemars(description = "Select default assumed format for any plaintext input. Currently supported options: [base64]")]
    input_format: Option<String>,
    #[schemars(description = "The item id of the key to use in the encryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the encryption process")]
    key_name: String,
    #[schemars(description = "Data to perform hmac on")]
    plaintext: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ImportPasswordsInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Password format type [LastPass/Chrome/Firefox/1password/keeper/bitwarden/dashlane]")]
    format: Option<String>,
    #[schemars(description = "File path")]
    import_path: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "Target folder for imported passwords")]
    target_folder: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    update_mode: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipClientDeleteRuleInput {
    client_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    name: Option<String>,
    #[schemars(description = "Access path")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipClientSetRuleInput {
    #[schemars(description = "Access capabilities")]
    capability: Vec<String>,
    client_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    name: Option<String>,
    #[schemars(description = "Access path")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipCreateClientInput {
    #[schemars(description = "If set to 'true', newly created keys on the client will be set to an 'active' state")]
    activate_keys_on_creation: Option<String>,
    #[schemars(description = "Client certificate TTL in days")]
    certificate_ttl: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Client name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipServerSetupInput {
    #[schemars(description = "Server certificate TTL in days")]
    certificate_ttl: Option<i64>,
    #[schemars(description = "Hostname")]
    hostname: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Root path of KMIP Resources")]
    root: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipDeleteClientInput {
    client_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipDeleteServerInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipDescribeClientInput {
    client_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipDescribeServerInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipListClientsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipMoveServerInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "New root for the kmip server")]
    new_root: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipRenewClientCertificateInput {
    client_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipRenewServerCertificateInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct KmipSetServerStateInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    state: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListAcmeAccountsInput {
    #[schemars(description = "The name of the PKI certificate issuer")]
    cert_issuer_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListAuthMethodsInput {
    #[schemars(description = "Filter by auth method name or part of it")]
    filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Next page reference")]
    pagination_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The Auth method types list of the requested method. In case it is empty, all types of auth methods will be returned. options: [api_key, azure_ad, oauth2/jwt, saml2, ldap, aws_iam, oidc, universal_identity, gcp, k8s, cert]")]
    type: Option<Vec<String>>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListGatewaysInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListGroupsInput {
    #[schemars(description = "Filter by auth method name or part of it")]
    filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Next page reference")]
    pagination_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListItemsInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Filter by item name/username/website or part of it")]
    advanced_filter: Option<String>,
    #[schemars(description = "Retrieve all items using pagination, when disabled retrieving only first 1000 items")]
    auto_pagination: Option<String>,
    #[schemars(description = "List only items in the current folder (excludes subfolders)")]
    current_folder: Option<bool>,
    #[schemars(description = "Filter by item name or part of it")]
    filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Show only basic information of the items")]
    minimal_view: Option<bool>,
    #[schemars(description = "List only secrets modified after specified date (in unix time)")]
    modified_after: Option<i64>,
    #[schemars(description = "Next page reference")]
    pagination_token: Option<String>,
    #[schemars(description = "Path to folder")]
    path: Option<String>,
    #[schemars(description = "Filter by items with SRA functionality enabled")]
    sra_only: Option<bool>,
    sub_types: Option<Vec<String>>,
    #[schemars(description = "Filter by item tag")]
    tag: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The item types list of the requested items. In case it is empty, all types of items will be returned. options: [key, static-secret, dynamic-secret, classic-key]")]
    type: Option<Vec<String>>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListRolesInput {
    #[schemars(description = "Filter by item name or part of it")]
    filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Next page reference")]
    pagination_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListSharedItemsInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListSraBastionsInput {
    #[schemars(description = "Filter the response to show only bastions allowed URLs")]
    allowed_urls_only: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListSraSessionsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "session resource type. In case it is empty, all resources type will be returned. options: [mysql, k8s, ssh, mongodb, mssql, postgres, aws, eks, gke, rdp]")]
    resource_type: Option<Vec<String>>,
    #[schemars(description = "session status type. In case it is empty, only active sessions will be returned. options: [connecting, connected, failed, completed, terminated]")]
    status_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ListTargetsInput {
    #[schemars(description = "Filter by auth method name or part of it")]
    filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Next page reference")]
    pagination_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The target types list . In case it is empty, all types of targets will be returned. options: [hanadb cassandra aws ssh gke eks mysql mongodb snowflake mssql redshift artifactory azure rabbitmq k8s venafi gcp oracle dockerhub ldap github chef web salesforce postgres]")]
    type: Option<Vec<String>>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct MoveObjectsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The objects type to move (item/auth_method/role)")]
    objects_type: Option<String>,
    #[schemars(description = "Source path to move the objects from")]
    source: String,
    #[schemars(description = "Target path to move the objects to")]
    target: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct PolicyCreateKeysInput {
    #[schemars(description = "Specify allowed key algorithms (e.g., [RSA2048,AES128GCM])")]
    allowed_algorithms: Option<Vec<String>>,
    #[schemars(description = "Specify allowed protection key names. To enforce using the account's default protection key, use 'default-account-key'")]
    allowed_key_names: Option<Vec<String>>,
    #[schemars(description = "Specify allowed key protection types (dfc, classic-key)")]
    allowed_key_types: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Set the maximum rotation interval for automatic key rotation.")]
    max_rotation_interval_days: Option<i64>,
    #[schemars(description = "The object types this policy will apply to (items, targets). If not provided, defaults to [items, targets].")]
    object_types: Option<Vec<String>>,
    #[schemars(description = "The path the policy refers to")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct PoliciesDeleteInput {
    #[schemars(description = "Policy id")]
    id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct PoliciesGetInput {
    #[schemars(description = "Policy id")]
    id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct PoliciesListInput {
    #[schemars(description = "Aggregate missing configurations from parent policies (requires --paths)")]
    aggregate: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Optional object types filter (items or targets)")]
    object_type: Option<Vec<String>>,
    #[schemars(description = "Filter by exact policy paths")]
    paths: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Filter by policy types")]
    types: Option<Vec<String>>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct PolicyUpdateKeysInput {
    #[schemars(description = "Specify allowed key algorithms (e.g., [RSA2048,AES128GCM])")]
    allowed_algorithms: Option<Vec<String>>,
    #[schemars(description = "Specify allowed protection key names. To enforce using the account's default protection key, use 'default-account-key'")]
    allowed_key_names: Option<Vec<String>>,
    #[schemars(description = "Specify allowed key protection types (dfc, classic-key)")]
    allowed_key_types: Option<Vec<String>>,
    #[schemars(description = "Policy id")]
    id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Set the maximum rotation interval for automatic key rotation.")]
    max_rotation_interval_days: Option<i64>,
    #[schemars(description = "The object type this policy will apply to (items, targets)")]
    object_types: Option<Vec<String>>,
    #[schemars(description = "The path the policy refers to")]
    path: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ProvisionCertificateInput {
    #[schemars(description = "Certificate display ID")]
    display_id: Option<String>,
    #[schemars(description = "Certificate item ID")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Certificate name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RawCredsInput {
    access_id: Option<String>,
    access_key: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RefreshKeyInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Key name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RenewCertificateInput {
    #[schemars(description = "The name of the PKI certificate issuer")]
    cert_issuer_name: Option<String>,
    #[schemars(description = "Generate a new key as part of the certificate renewal")]
    generate_key: Option<bool>,
    #[schemars(description = "Certificate item id")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Certificate name")]
    name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RequestAccessInput {
    #[schemars(description = "List of the required capabilities options: [read, update, delete]")]
    capability: Vec<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Item name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Item type")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ResetAccessKeyInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ReverseRbacInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Path to an object")]
    path: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Type of object (item, am, role)")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RevokeCertificateInput {
    #[schemars(description = "The item id of the certificate to revoke")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Certificate item name to revoke")]
    name: Option<String>,
    #[schemars(description = "The serial number of the certificate to revoke")]
    serial_number: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Certificate version to revoke. Required if item-id or name are used.")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RollbackSecretInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Secret name")]
    name: String,
    #[schemars(description = "Old secret version to rollback to")]
    old_version: i64,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotateKeyInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Key name")]
    name: String,
    #[schemars(description = "The new pem encoded certificate for the classic key. relevant only for keys provided by user ('bring-your-own-key')")]
    new_cert_pem_data: Option<String>,
    #[schemars(description = "The new base64 encoded value for the classic key. relevant only for keys provided by user ('bring-your-own-key')")]
    new_key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotateOidcClientSecretInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "OIDC application name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateAwsInput {
    #[schemars(description = "API ID to rotate (relevant only for rotator-type=api-key)")]
    api_id: Option<String>,
    #[schemars(description = "API key to rotate (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Aws Region")]
    aws_region: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable graceful rotation (keep both versions temporarily). When enabled, a new secret version is created while the previous version is kept for the grace period, so both versions exist for a limited time. [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "The Hour of the grace rotation in UTC")]
    grace_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait before deleting the old key (must be bigger than rotation-interval)")]
    grace_rotation_interval: Option<String>,
    #[schemars(description = "When to create the new version relative to the rotation date [after/before]")]
    grace_rotation_timing: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/api-key]")]
    rotator_type: String,
    #[schemars(description = "The AWS account id")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateAzureInput {
    #[schemars(description = "API ID to rotate (relevant only for rotator-type=api-key)")]
    api_id: Option<String>,
    #[schemars(description = "API key to rotate (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "Id of the azure app that hold the serect to be rotated (relevant only for rotator-type=api-key & authentication-credentials=use-target-creds)")]
    application_id: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "If set, explicitly provide the storage account details [true/false]")]
    explicitly_set_sa: Option<String>,
    #[schemars(description = "Enable graceful rotation (keep both versions temporarily). When enabled, a new secret version is created while the previous version is kept for the grace period, so both versions exist for a limited time. [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "The Hour of the grace rotation in UTC")]
    grace_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait before deleting the old key (must be bigger than rotation-interval)")]
    grace_rotation_interval: Option<String>,
    #[schemars(description = "When to create the new version relative to the rotation date [after/before]")]
    grace_rotation_timing: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "The resource group name (only relevant when explicitly-set-sa=true)")]
    resource_group_name: Option<String>,
    #[schemars(description = "The name of the storage account (only relevant when explicitly-set-sa=true)")]
    resource_name: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password/api-key/azure-storage-account]")]
    rotator_type: String,
    #[schemars(description = "Enable this flag to prevent simultaneous use of the same secret")]
    secure_access_disable_concurrent_connections: Option<bool>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "The name of the storage account key to rotate [key1/key2/kerb1/kerb2] (relevat to azure-storage-account)")]
    storage_account_key_name: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The user principal name to rotate his password (relevant only for rotator-type=password)")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateCassandraInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateCustomInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Secret payload to be sent with rotation request")]
    custom_payload: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable password policy")]
    enable_password_policy: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Override the SSH username as indicated in SSH Certificate Issuer")]
    secure_access_ssh_user: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Maximum allowed time in seconds for the custom rotator to return the results")]
    timeout_sec: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Password must contain capital letters [true/false]")]
    use_capital_letters: Option<String>,
    #[schemars(description = "Password must contain lower case letters [true/false]")]
    use_lower_letters: Option<String>,
    #[schemars(description = "Password must contain numbers [true/false]")]
    use_numbers: Option<String>,
    #[schemars(description = "Password must contain special characters [true/false]")]
    use_special_characters: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateDockerhubInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateGcpInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "The email of the gcp service account to rotate")]
    gcp_service_account_email: Option<String>,
    #[schemars(description = "The key id of the gcp service account to rotate")]
    gcp_service_account_key_id: Option<String>,
    #[schemars(description = "Enable graceful rotation (keep both versions temporarily). When enabled, a new secret version is created while the previous version is kept for the grace period, so both versions exist for a limited time. [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "The Hour of the grace rotation in UTC")]
    grace_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait before deleting the old key (must be bigger than rotation-interval)")]
    grace_rotation_interval: Option<String>,
    #[schemars(description = "When to create the new version relative to the rotation date [after/before]")]
    grace_rotation_timing: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/service-account-rotator]")]
    rotator_type: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateHanadbInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateLdapInput {
    provider_type: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=ldap)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=ldap)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/ldap]")]
    rotator_type: String,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "LDAP User Attribute, Default value \"cn\"")]
    user_attribute: Option<String>,
    #[schemars(description = "Base DN to Perform User Search")]
    user_dn: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateMongodbInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateMssqlInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateMysqlInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateOpenAiInput {
    #[schemars(description = "Admin API key value to rotate (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "Admin API key ID to rotate (relevant only for rotator-type=api-key)")]
    api_key_id: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/api-key]")]
    rotator_type: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateOracledbInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreatePostgresqlInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateRedisInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateRedshiftInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateSnowflakeInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded) to rotate (relevant only for rotator-type=key)")]
    private_key: Option<String>,
    #[schemars(description = "The path to the file containing the private key (relevant only for rotator-type=key)")]
    private_key_file_name: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password or rotator-type=key)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password/key]")]
    rotator_type: String,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateSplunkInput {
    #[schemars(description = "Token audience for Splunk token creation (required for rotator-type=token)")]
    audience: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Token expiration date in YYYY-MM-DD format (required for rotator-type=token when manual rotation is selected and no existing token is provided). Time will be set to 00:00 UTC.")]
    expiration_date: Option<String>,
    #[schemars(description = "Current Splunk HEC token value to store (relevant only for rotator-type=hec-token). If not provided, a new HEC input will be created in Splunk.")]
    hec_token: Option<String>,
    #[schemars(description = "Splunk HEC input name to manage  (required for rotator-type=hec-token)")]
    hec_token_name: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password/token/hec-token]")]
    rotator_type: String,
    #[schemars(description = "Current Splunk authentication token to store (relevant only for rotator-type=token). If not provided, a new token will be created in Splunk.")]
    splunk_token: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Splunk token owner username (relevant only for rotator-type=token)")]
    token_owner: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateSshInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Private key file contents encoded using base64")]
    key_data_base64: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "The path to the public key that will be rotated on the server")]
    public_key_remote_path: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Custom rotation command")]
    rotator_custom_cmd: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password/key]")]
    rotator_type: String,
    #[schemars(description = "Rotate same password for each host from the Linked Target (relevant only for Linked Target)")]
    same_password: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Override the SSH username as indicated in SSH Certificate Issuer")]
    secure_access_ssh_user: Option<String>,
    #[schemars(description = "Specify target type. Options are ssh or rdp")]
    secure_access_target_type: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretCreateWindowsInput {
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Rotate same password for each host from the Linked Target (relevant only for Linked Target)")]
    same_password: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Add tags attached to this object")]
    tags: Option<Vec<String>>,
    #[schemars(description = "The target name to associate")]
    target_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretDeleteInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The specific version you want to delete, -1=entire item with all versions (default)")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretDeleteSyncInput {
    #[schemars(description = "Delete the secret from the remote target USC as well")]
    delete_from_usc: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "Remote Secret Name to disambiguate when multiple syncs exist under the same USC")]
    remote_secret_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Universal Secret Connector name")]
    usc_name: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretGetValueInput {
    #[schemars(description = "Get rotated secret value of specific Host (relevant only for Linked Target)")]
    host: Option<String>,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Secret name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Secret version")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretListInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretSyncInput {
    #[schemars(description = "Delete the secret from remote secret manager (for association create/update)")]
    delete_remote: Option<bool>,
    #[schemars(description = "JQ expression to filter or transform the secret value")]
    filter_secret_value: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "Vault namespace, releavnt only for Hashicorp Vault Target")]
    namespace: Option<String>,
    #[schemars(description = "Remote Secret Name that will be synced on the remote endpoint")]
    remote_secret_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Universal Secret Connector name, If not provided all attached USC's will be synced")]
    usc_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateAwsInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "API ID to rotate (relevant only for rotator-type=api-key)")]
    api_id: Option<String>,
    #[schemars(description = "API key to rotate (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Aws Region")]
    aws_region: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable graceful rotation (keep both versions temporarily). When enabled, a new secret version is created while the previous version is kept for the grace period, so both versions exist for a limited time. [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "The Hour of the grace rotation in UTC")]
    grace_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait before deleting the old key (must be bigger than rotation-interval)")]
    grace_rotation_interval: Option<String>,
    #[schemars(description = "When to create the new version relative to the rotation date [after/before]")]
    grace_rotation_timing: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The AWS account id")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateAzureInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "API ID to rotate (relevant only for rotator-type=api-key)")]
    api_id: Option<String>,
    #[schemars(description = "API key to rotate (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "Id of the azure app that hold the serect to be rotated (relevant only for rotator-type=api-key & authentication-credentials=use-target-creds)")]
    application_id: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "If set, explicitly provide the storage account details [true/false]")]
    explicitly_set_sa: Option<String>,
    #[schemars(description = "Enable graceful rotation (keep both versions temporarily). When enabled, a new secret version is created while the previous version is kept for the grace period, so both versions exist for a limited time. [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "The Hour of the grace rotation in UTC")]
    grace_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait before deleting the old key (must be bigger than rotation-interval)")]
    grace_rotation_interval: Option<String>,
    #[schemars(description = "When to create the new version relative to the rotation date [after/before]")]
    grace_rotation_timing: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "The resource group name (only relevant when explicitly-set-sa=true)")]
    resource_group_name: Option<String>,
    #[schemars(description = "The name of the storage account (only relevant when explicitly-set-sa=true)")]
    resource_name: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Enable this flag to prevent simultaneous use of the same secret")]
    secure_access_disable_concurrent_connections: Option<bool>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "The name of the storage account key to rotate [key1/key2/kerb1/kerb2] (relevat to azure-storage-account)")]
    storage_account_key_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The user principal name to rotate his password (relevant only for rotator-type=password)")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateCassandraInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateCustomInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Secret payload to be sent with rotation request")]
    custom_payload: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Enable password policy")]
    enable_password_policy: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Override the SSH username as indicated in SSH Certificate Issuer")]
    secure_access_ssh_user: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Maximum allowed time in seconds for the custom rotator to return the results")]
    timeout_sec: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Password must contain capital letters [true/false]")]
    use_capital_letters: Option<String>,
    #[schemars(description = "Password must contain lower case letters [true/false]")]
    use_lower_letters: Option<String>,
    #[schemars(description = "Password must contain numbers [true/false]")]
    use_numbers: Option<String>,
    #[schemars(description = "Password must contain special characters [true/false]")]
    use_special_characters: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateDockerhubInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateGcpInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "The email of the gcp service account to rotate")]
    gcp_service_account_email: Option<String>,
    #[schemars(description = "The key id of the gcp service account to rotate")]
    gcp_service_account_key_id: Option<String>,
    #[schemars(description = "Enable graceful rotation (keep both versions temporarily). When enabled, a new secret version is created while the previous version is kept for the grace period, so both versions exist for a limited time. [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "The Hour of the grace rotation in UTC")]
    grace_rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait before deleting the old key (must be bigger than rotation-interval)")]
    grace_rotation_interval: Option<String>,
    #[schemars(description = "When to create the new version relative to the rotation date [after/before]")]
    grace_rotation_timing: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/service-account-rotator]")]
    rotator_type: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateHanadbInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateLdapInput {
    provider_type: Option<String>,
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=ldap)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=ldap)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "A list of linked targets to be associated, Relevant only for Secure Remote Access for ssh cert issuer, ldap rotated secret and ldap dynamic secret, To specify multiple targets use argument multiple times")]
    target: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "LDAP User Attribute, Default value \"cn\"")]
    user_attribute: Option<String>,
    #[schemars(description = "Base DN to Perform User Search")]
    user_dn: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateMongodbInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateMssqlInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateMysqlInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateOpenAiInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "Admin API key value to update (relevant only for rotator-type=api-key)")]
    api_key: Option<String>,
    #[schemars(description = "Admin API key ID to update (relevant only for rotator-type=api-key)")]
    api_key_id: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateOracledbInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdatePostgresqlInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateRedisInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateRedshiftInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateSnowflakeInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded) to rotate (relevant only for rotator-type=key)")]
    private_key: Option<String>,
    #[schemars(description = "The path to the file containing the private key (relevant only for rotator-type=key)")]
    private_key_file_name: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password or rotator-type=key)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateSplunkInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "Token audience for Splunk token creation (relevant only for rotator-type=token)")]
    audience: Option<String>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Token expiration date in YYYY-MM-DD format (relevant only for rotator-type=token when manual rotation is selected). Time will be set to 00:00 UTC.")]
    expiration_date: Option<String>,
    #[schemars(description = "For rotator-type=hec-token, optionally set/replace the stored HEC token value.")]
    hec_token: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "For rotator-type=token, optionally set/replace the stored Splunk authentication token value.")]
    splunk_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "For rotator-type=token, specify the Splunk username that the new token should be issued for. (Splunk 10 requires name=<token-owner> when creating auth tokens.)")]
    token_owner: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateSshInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Private key file contents encoded using base64")]
    key_data_base64: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "The path to the public key that will be rotated on the server")]
    public_key_remote_path: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "Custom rotation command")]
    rotator_custom_cmd: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password/key]")]
    rotator_type: String,
    #[schemars(description = "Rotate same password for each host from the Linked Target (relevant only for Linked Target)")]
    same_password: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Override the SSH username as indicated in SSH Certificate Issuer")]
    secure_access_ssh_user: Option<String>,
    #[schemars(description = "Specify target type. Options are ssh or rdp")]
    secure_access_target_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct RotatedSecretUpdateWindowsInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "The credentials to connect with use-user-creds/use-target-creds")]
    authentication_credentials: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Rotated secret name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "The length of the password to be generated")]
    password_length: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password (relevant only for rotator-type=password)")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password (relevant only for rotator-type=password)")]
    rotated_username: Option<String>,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (1-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The rotator type. options: [target/password]")]
    rotator_type: String,
    #[schemars(description = "Rotate same password for each host from the Linked Target (relevant only for Linked Target)")]
    same_password: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Default domain name server. i.e. microsoft.com")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SetItemStateInput {
    #[schemars(description = "Desired item state (Enabled, Disabled)")]
    desired_state: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Current item name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The specific version you want to update: 0=item level state (default) (relevant only for keys)")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SetRoleRuleInput {
    #[schemars(description = "List of the approved/denied capabilities in the path options: [read, create, update, delete, list, deny]")]
    capability: Vec<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The path the rule refers to")]
    path: String,
    #[schemars(description = "The role name to be updated")]
    role_name: String,
    #[schemars(description = "item-rule, target-rule, role-rule, auth-method-rule, search-rule, reports-rule, gw-reports-rule or sra-reports-rule, sra-rule")]
    rule_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "RoleRule ttl")]
    ttl: Option<i64>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ShareItemInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "Action to be performed on the item [start/stop/describe]")]
    action: String,
    #[schemars(description = "List of emails to start/stop sharing the secret with")]
    emails: Option<Vec<String>>,
    #[schemars(description = "Item name")]
    item_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Share type [email/token]")]
    share_type: Option<String>,
    #[schemars(description = "Shared token ids in order to stop sharing a secret")]
    shared_token_id: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "TTL of the Availability of the shared secret in seconds")]
    ttl: Option<i64>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "ViewOnlyOnce Shared secrets can only be viewed once [true/false]")]
    view_once: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SignDataWithClassicKeyInput {
    #[schemars(description = "Data")]
    data: String,
    #[schemars(description = "The name of the key to use in the sign data process")]
    display_id: String,
    #[schemars(description = "Defines whether the data should be hashed as part of the signing. If true, the data will not be hashed")]
    hashed: Option<bool>,
    #[schemars(description = "HashingMethod")]
    hashing_method: Option<String>,
    #[schemars(description = "Retrieve the Secret value without checking the Gateway's cache [true/false]. This flag is only relevant when using the RestAPI")]
    ignore_cache: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "ClassicKey name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SignEcDsaInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "The display id of the EC key to use for the signing process")]
    display_id: Option<String>,
    #[schemars(description = "The item id of the EC key to use for the signing process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the EC key to use for the signing process")]
    key_name: Option<String>,
    #[schemars(description = "The input message to sign in a base64 format")]
    message: String,
    #[schemars(description = "Markes that the message is already hashed")]
    prehashed: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The version of the key to use for signing")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SignGpgInput {
    #[schemars(description = "The display id of the key to use in the encryption process")]
    display_id: Option<String>,
    #[schemars(description = "The item id of the key to use in the encryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the encryption process")]
    key_name: String,
    #[schemars(description = "The message to be signed in base64 format")]
    message: String,
    #[schemars(description = "Passphrase that was used to generate the key")]
    passphrase: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SignJwtWithClassicKeyInput {
    #[schemars(description = "The name of the key to use in the sign JWT process")]
    display_id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "JWTClaims")]
    jwt_claims: String,
    #[schemars(description = "SigningMethod")]
    signing_method: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SignPkcs1Input {
    #[schemars(description = "The display id of the key to use in the signing process")]
    display_id: Option<String>,
    #[schemars(description = "HashFunction defines the hash function (e.g. sha-256)")]
    hash_function: Option<String>,
    #[schemars(description = "Select default assumed format for the plaintext message. Currently supported options: [base64]")]
    input_format: Option<String>,
    #[schemars(description = "The item id of the key to use in the signing process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the RSA key to use in the signing process")]
    key_name: Option<String>,
    #[schemars(description = "The message to be signed")]
    message: String,
    #[schemars(description = "Markes that the message is already hashed")]
    prehashed: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The version of the key to use for signing")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SignPkiCertWithClassicKeyInput {
    #[schemars(description = "The common name to be included in the PKI certificate")]
    common_name: Option<String>,
    #[schemars(description = "A comma-separated list of the country that will be set in the issued certificate")]
    country: Option<String>,
    #[schemars(description = "The name of the key to use in the sign PKI Cert process")]
    display_id: String,
    #[schemars(description = "DNS Names to be included in the PKI certificate (in a comma-delimited list)")]
    dns_names: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "key-usage")]
    key_usage: Option<String>,
    #[schemars(description = "A comma-separated list of the locality that will be set in the issued certificate")]
    locality: Option<String>,
    #[schemars(description = "A comma-separated list of organizational units (OU) that will be set in the issued certificate")]
    organizational_units: Option<String>,
    #[schemars(description = "A comma-separated list of organizations (O) that will be set in the issued certificate")]
    organizations: Option<String>,
    #[schemars(description = "A comma-separated list of the postal code that will be set in the issued certificate")]
    postal_code: Option<String>,
    #[schemars(description = "A comma-separated list of the province that will be set in the issued certificate")]
    province: Option<String>,
    #[schemars(description = "PublicKey using for signing in a PEM format.")]
    public_key_pem_data: Option<String>,
    #[schemars(description = "SigningMethod")]
    signing_method: String,
    #[schemars(description = "A comma-separated list of the street address that will be set in the issued certificate")]
    street_address: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "he requested Time To Live for the certificate, in seconds")]
    ttl: i64,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The URI Subject Alternative Names to be included in the PKI certificate (in a comma-delimited list)")]
    uri_sans: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct SignRsaSsaPssInput {
    #[schemars(description = "The display id of the RSA key to use in the signing process")]
    display_id: Option<String>,
    #[schemars(description = "HashFunction defines the hash function (e.g. sha-256)")]
    hash_function: Option<String>,
    #[schemars(description = "The item id of the RSA key to use in the signing process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the RSA key to use in the signing process")]
    key_name: Option<String>,
    #[schemars(description = "The input message to sign in a base64 format")]
    message: String,
    #[schemars(description = "Markes that the message is already hashed")]
    prehashed: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The version of the key to use for signing")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct StaticCredsAuthInput {
    #[schemars(description = "Akeyless JWT token")]
    access_id: Option<String>,
    #[schemars(description = "Akeyless JWT token")]
    admin_email: Option<String>,
    #[schemars(description = "Akeyless JWT token")]
    creds: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct StaticSecretDeleteSyncInput {
    #[schemars(description = "Delete the secret from the remote target USC as well")]
    delete_from_usc: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Static secret name")]
    name: String,
    #[schemars(description = "Remote Secret Name to disambiguate when multiple syncs exist under the same USC")]
    remote_secret_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Universal Secret Connector name")]
    usc_name: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct StaticSecretSyncInput {
    #[schemars(description = "Delete the secret from remote secret manager (for association create/update)")]
    delete_remote: Option<bool>,
    #[schemars(description = "JQ expression to filter or transform the secret value")]
    filter_secret_value: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Static secret name")]
    name: String,
    #[schemars(description = "Vault namespace, releavnt only for Hashicorp Vault Target")]
    namespace: Option<String>,
    #[schemars(description = "Remote Secret Name that will be synced on the remote endpoint")]
    remote_secret_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Universal Secret Connector name, If not provided all attached USC's will be synced")]
    usc_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateArtifactoryInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: String,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: String,
    #[schemars(description = "Base URL")]
    base_url: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateAwsInput {
    #[schemars(description = "AWS secret access key")]
    access_key: String,
    #[schemars(description = "AWS access key ID")]
    access_key_id: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A unique auto-generated value used in your AWS account when configuring your AWS IAM role to securely delegate access to Akeyless. Relevant only when using GW cloud ID")]
    generate_external_id: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "AWS region")]
    region: Option<String>,
    #[schemars(description = "AWS IAM role identifier that Gateway will assume in your AWS account, relevant only when using external ID")]
    role_arn: Option<String>,
    #[schemars(description = "Required only for temporary security credentials retrieved using STS")]
    session_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateAzureInput {
    #[schemars(description = "Azure cloud environment to use. Values: AzureCloud (default), AzureUSGovernment, AzureChinaCloud.")]
    azure_cloud: Option<String>,
    #[schemars(description = "Azure client/application id")]
    client_id: Option<String>,
    #[schemars(description = "Azure client secret")]
    client_secret: Option<String>,
    #[schemars(description = "Type of connection [credentials/cloud-identity]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "The Resource Group name in your Azure subscription")]
    resource_group_name: Option<String>,
    #[schemars(description = "The name of the relevant Resource")]
    resource_name: Option<String>,
    #[schemars(description = "Azure Subscription Id")]
    subscription_id: Option<String>,
    #[schemars(description = "Azure tenant id")]
    tenant_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM [Deprecated: Use connection-type=cloud-identity]")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateDbInput {
    #[schemars(description = "(Optional) Client id (relevant for \"cloud-service-provider\" only)")]
    azure_client_id: Option<String>,
    #[schemars(description = "(Optional) Client secret (relevant for \"cloud-service-provider\" only)")]
    azure_client_secret: Option<String>,
    #[schemars(description = "(Optional) Tenant id (relevant for \"cloud-service-provider\" only)")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "(Optional) Cloud service provider (currently only supports Azure)")]
    cloud_service_provider: Option<String>,
    #[schemars(description = "Cluster Mode")]
    cluster_mode: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Type of connection to mssql database [credentials/cloud-identity/wallet/parent-target]")]
    connection_type: String,
    db_name: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    db_type: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    mongodb_atlas: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Oracle db service name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Wallet login type (password/mtls)")]
    oracle_wallet_login_type: Option<String>,
    #[schemars(description = "Oracle wallet p12 file data in base64")]
    oracle_wallet_p12_file_data: Option<String>,
    #[schemars(description = "Oracle wallet sso file data in base64")]
    oracle_wallet_sso_file_data: Option<String>,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    port: Option<String>,
    pwd: Option<String>,
    snowflake_account: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    snowflake_api_private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    snowflake_api_private_key_password: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    user_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateDockerhubInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Password for docker repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Username for docker repository")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateEksInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: String,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: String,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: String,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: String,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGcpInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGeminiInput {
    #[schemars(description = "API key for Gemini")]
    api_key: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base URL of the Gemini API")]
    gemini_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGithubInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGitlabInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Gitlab access token")]
    gitlab_access_token: Option<String>,
    #[schemars(description = "Gitlab tls certificate (base64 encoded)")]
    gitlab_certificate: Option<String>,
    #[schemars(description = "Gitlab base url")]
    gitlab_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGkeInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGlobalSignInput {
    #[schemars(description = "Email of the GlobalSign GCC account contact")]
    contact_email: String,
    #[schemars(description = "First name of the GlobalSign GCC account contact")]
    contact_first_name: String,
    #[schemars(description = "Last name of the GlobalSign GCC account contact")]
    contact_last_name: String,
    #[schemars(description = "Telephone of the GlobalSign GCC account contact")]
    contact_phone: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Password of the GlobalSign GCC account")]
    password: String,
    #[schemars(description = "Profile ID of the GlobalSign GCC account")]
    profile_id: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Username of the GlobalSign GCC account")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGlobalSignAtlasInput {
    #[schemars(description = "API Key of the GlobalSign Atlas account")]
    api_key: String,
    #[schemars(description = "API Secret of the GlobalSign Atlas account")]
    api_secret: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Mutual TLS Certificate contents of the GlobalSign Atlas account encoded in base64, either mtls-cert-file-path or mtls-cert-data-base64 must be supplied")]
    mtls_cert_data_base64: Option<String>,
    #[schemars(description = "Mutual TLS Key contents of the GlobalSign Atlas account encoded in base64, either mtls-key-file-path or mtls-data-base64 must be supplied")]
    mtls_key_data_base64: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateGodaddyInput {
    #[schemars(description = "Key of the api credentials to the Godaddy account")]
    api_key: String,
    #[schemars(description = "Customer ID (ShopperId) required for renewal of imported certificates")]
    customer_id: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Secret of the api credentials to the Godaddy account")]
    secret: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateHashiVaultInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "HashiCorp Vault API URL, e.g. https://vault-mgr01:8200")]
    hashi_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Comma-separated list of vault namespaces")]
    namespace: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Vault access token with sufficient permissions")]
    vault_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateK8sInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S auth type [token/certificate]")]
    k8s_auth_type: Option<String>,
    #[schemars(description = "Content of the k8 client certificate (PEM format) in a Base64 format")]
    k8s_client_certificate: Option<String>,
    #[schemars(description = "Content of the k8 client private key (PEM format) in a Base64 format")]
    k8s_client_key: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateLdapInput {
    #[schemars(description = "Bind DN")]
    bind_dn: String,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: String,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Set Ldap server type, Options:[OpenLDAP, ActiveDirectory]. Default is OpenLDAP")]
    server_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateLetsEncryptInput {
    acme_challenge: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Name of existing cloud target for DNS credentials. Required when acme-challenge=dns. Supported: AWS, Azure, GCP targets")]
    dns_target_creds: Option<String>,
    #[schemars(description = "Email address for ACME account registration")]
    email: Option<String>,
    #[schemars(description = "GCP Cloud DNS: Project ID. Optional - can be derived from service account")]
    gcp_project: Option<String>,
    #[schemars(description = "AWS Route53 hosted zone ID. Required when dns-target-creds points to AWS target")]
    hosted_zone: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    lets_encrypt_url: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Azure resource group name. Required when dns-target-creds points to Azure target")]
    resource_group: Option<String>,
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateLinkedInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of server hosts and server descriptions joined by semicolon ';' (i.e. 'server-dev.com;My Dev server,server-prod.com;My Prod server description')")]
    hosts: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "The parent Target name")]
    parent_target_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Specifies the hosts type, relevant only when working without parent target")]
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateOpenAiInput {
    #[schemars(description = "API key for OpenAI")]
    api_key: Option<String>,
    #[schemars(description = "API key ID")]
    api_key_id: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Default model to use with OpenAI")]
    model: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Base URL of the OpenAI API")]
    openai_url: Option<String>,
    #[schemars(description = "Organization ID")]
    organization_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreatePingInput {
    #[schemars(description = "Ping Federate administrative port")]
    administrative_port: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    authorization_port: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Ping Federate privileged user password")]
    password: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    privileged_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateRabbitMqInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    rabbitmq_server_password: Option<String>,
    rabbitmq_server_uri: Option<String>,
    rabbitmq_server_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateSalesforceInput {
    #[schemars(description = "Base64 encoded PEM of the connected app private key (relevant for JWT auth only)")]
    app_private_key_data: Option<String>,
    #[schemars(description = "type of the auth flow ('jwt' / 'user-password')")]
    auth_flow: String,
    #[schemars(description = "Base64 encoded PEM cert to use when uploading a new key to Salesforce")]
    ca_cert_data: Option<String>,
    #[schemars(description = "name of the certificate in Salesforce tenant to use when uploading new key")]
    ca_cert_name: Option<String>,
    #[schemars(description = "Client ID of the oauth2 app to use for connecting to Salesforce")]
    client_id: String,
    #[schemars(description = "Client secret of the oauth2 app to use for connecting to Salesforce (required for password flow)")]
    client_secret: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "The email of the user attached to the oauth2 app used for connecting to Salesforce")]
    email: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "The password of the user attached to the oauth2 app used for connecting to Salesforce (required for user-password flow)")]
    password: Option<String>,
    #[schemars(description = "The security token of the user attached to the oauth2 app used for connecting to Salesforce  (required for user-password flow)")]
    security_token: Option<String>,
    #[schemars(description = "Url of the Salesforce tenant")]
    tenant_url: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateSectigoInput {
    #[schemars(description = "Certificate Profile ID in Sectigo account")]
    certificate_profile_id: i64,
    #[schemars(description = "Customer Uri of the Sectigo account")]
    customer_uri: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "External Requester - a comma separated list of emails")]
    external_requester: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Organization ID in Sectigo account")]
    organization_id: i64,
    #[schemars(description = "Password of the Sectigo account user")]
    password: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Username of the Sectigo account")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateSplunkInput {
    #[schemars(description = "Splunk token audience (required when using token authentication for rotation)")]
    audience: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Splunk Password (used when authenticating with username/password)")]
    password: Option<String>,
    #[schemars(description = "Splunk Token (used when authenticating with token)")]
    token: Option<String>,
    #[schemars(description = "Splunk Token Owner (required when using token authentication for rotation)")]
    token_owner: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Splunk server URL")]
    url: String,
    #[schemars(description = "Use TLS certificate verification when connecting to the Splunk management API")]
    use_tls: Option<bool>,
    #[schemars(description = "Splunk Username (used when authenticating with username/password)")]
    username: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateSshInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "SSH host name")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "SSH port")]
    port: Option<String>,
    #[schemars(description = "SSH private key")]
    private_key: Option<String>,
    #[schemars(description = "SSH private key password")]
    private_key_password: Option<String>,
    #[schemars(description = "SSH password to rotate")]
    ssh_password: Option<String>,
    #[schemars(description = "SSH username")]
    ssh_username: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateWebInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The url")]
    url: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateWindowsInput {
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    certificate: Option<String>,
    #[schemars(description = "Type of connection to Windows Server [credentials/parent-target]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "User domain name")]
    domain: Option<String>,
    #[schemars(description = "Server hostname")]
    hostname: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    #[schemars(description = "Privileged user password")]
    password: String,
    #[schemars(description = "Server WinRM port")]
    port: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Enable/Disable TLS for WinRM over HTTPS [true/false]")]
    use_tls: Option<String>,
    #[schemars(description = "Privileged username")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetCreateZeroSslInput {
    #[schemars(description = "API Key of the ZeroSSLTarget account")]
    api_key: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapValidationEmail to use when asking ZeroSSL to send a validation email, if empty will user imap-username")]
    imap_target_email: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetDeleteInput {
    #[schemars(description = "Enforce deletion")]
    force_deletion: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Target version")]
    target_version: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetGetInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Include all target versions in reply")]
    show_versions: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetGetDetailsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Include all target versions in reply")]
    show_versions: Option<bool>,
    #[schemars(description = "Target version")]
    target_version: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetListInput {
    #[schemars(description = "Filter by auth method name or part of it")]
    filter: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Next page reference")]
    pagination_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The target types list . In case it is empty, all types of targets will be returned. options: [hanadb cassandra aws ssh gke eks mysql mongodb snowflake mssql redshift artifactory azure rabbitmq k8s venafi gcp oracle dockerhub ldap github chef web salesforce postgres]")]
    type: Option<Vec<String>>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateArtifactoryInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: String,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: String,
    #[schemars(description = "Base URL")]
    base_url: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateAwsInput {
    #[schemars(description = "AWS secret access key")]
    access_key: String,
    #[schemars(description = "AWS access key ID")]
    access_key_id: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A unique auto-generated value used in your AWS account when configuring your AWS IAM role to securely delegate access to Akeyless. Relevant only when using GW cloud ID")]
    generate_external_id: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "AWS region")]
    region: Option<String>,
    #[schemars(description = "AWS IAM role identifier that Gateway will assume in your AWS account, relevant only when using external ID")]
    role_arn: Option<String>,
    #[schemars(description = "Required only for temporary security credentials retrieved using STS")]
    session_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateAzureInput {
    #[schemars(description = "Azure cloud environment to use. Values: AzureCloud (default), AzureUSGovernment, AzureChinaCloud.")]
    azure_cloud: Option<String>,
    #[schemars(description = "Azure client/application id")]
    client_id: Option<String>,
    #[schemars(description = "Azure client secret")]
    client_secret: Option<String>,
    #[schemars(description = "Type of connection [credentials/cloud-identity]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "The Resource Group name in your Azure subscription")]
    resource_group_name: Option<String>,
    #[schemars(description = "The name of the relevant Resource")]
    resource_name: Option<String>,
    #[schemars(description = "Azure Subscription Id")]
    subscription_id: Option<String>,
    #[schemars(description = "Azure tenant id")]
    tenant_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's Cloud IAM [Deprecated: Use connection-type=cloud-identity]")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateDbInput {
    #[schemars(description = "(Optional) Client id (relevant for \"cloud-service-provider\" only)")]
    azure_client_id: Option<String>,
    #[schemars(description = "(Optional) Client secret (relevant for \"cloud-service-provider\" only)")]
    azure_client_secret: Option<String>,
    #[schemars(description = "(Optional) Tenant id (relevant for \"cloud-service-provider\" only)")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "(Optional) Cloud service provider (currently only supports Azure)")]
    cloud_service_provider: Option<String>,
    #[schemars(description = "Cluster Mode")]
    cluster_mode: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Type of connection to mssql database [credentials/cloud-identity/wallet/parent-target]")]
    connection_type: String,
    db_name: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    db_type: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    mongodb_atlas: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Oracle db service name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Wallet login type (password/mtls)")]
    oracle_wallet_login_type: Option<String>,
    #[schemars(description = "Oracle wallet p12 file data in base64")]
    oracle_wallet_p12_file_data: Option<String>,
    #[schemars(description = "Oracle wallet sso file data in base64")]
    oracle_wallet_sso_file_data: Option<String>,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    port: Option<String>,
    pwd: Option<String>,
    snowflake_account: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    snowflake_api_private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    snowflake_api_private_key_password: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    user_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateDockerhubInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Password for docker repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Username for docker repository")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateEksInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: String,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: String,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: String,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: String,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGcpInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGeminiInput {
    #[schemars(description = "API key for Gemini")]
    api_key: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base URL of the Gemini API")]
    gemini_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_comment: Option<String>,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGithubInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGitlabInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Gitlab access token")]
    gitlab_access_token: Option<String>,
    #[schemars(description = "Gitlab tls certificate (base64 encoded)")]
    gitlab_certificate: Option<String>,
    #[schemars(description = "Gitlab base url")]
    gitlab_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGkeInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGlobalSignInput {
    #[schemars(description = "Email of the GlobalSign GCC account contact")]
    contact_email: String,
    #[schemars(description = "First name of the GlobalSign GCC account contact")]
    contact_first_name: String,
    #[schemars(description = "Last name of the GlobalSign GCC account contact")]
    contact_last_name: String,
    #[schemars(description = "Telephone of the GlobalSign GCC account contact")]
    contact_phone: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Password of the GlobalSign GCC account")]
    password: String,
    #[schemars(description = "Profile ID of the GlobalSign GCC account")]
    profile_id: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Username of the GlobalSign GCC account")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGlobalSignAtlasInput {
    #[schemars(description = "API Key of the GlobalSign Atlas account")]
    api_key: String,
    #[schemars(description = "API Secret of the GlobalSign Atlas account")]
    api_secret: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Mutual TLS Certificate contents of the GlobalSign Atlas account encoded in base64, either mtls-cert-file-path or mtls-cert-data-base64 must be supplied")]
    mtls_cert_data_base64: Option<String>,
    #[schemars(description = "Mutual TLS Key contents of the GlobalSign Atlas account encoded in base64, either mtls-key-file-path or mtls-data-base64 must be supplied")]
    mtls_key_data_base64: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateGodaddyInput {
    #[schemars(description = "Key of the api credentials to the Godaddy account")]
    api_key: String,
    #[schemars(description = "Customer ID (ShopperId) required for renewal of imported certificates")]
    customer_id: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Secret of the api credentials to the Godaddy account")]
    secret: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateHashiVaultInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "HashiCorp Vault API URL, e.g. https://vault-mgr01:8200")]
    hashi_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Comma-separated list of vault namespaces")]
    namespace: Option<Vec<String>>,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Vault access token with sufficient permissions")]
    vault_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateK8sInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S auth type [token/certificate]")]
    k8s_auth_type: Option<String>,
    #[schemars(description = "Content of the k8 client certificate (PEM format) in a Base64 format")]
    k8s_client_certificate: Option<String>,
    #[schemars(description = "Content of the k8 client private key (PEM format) in a Base64 format")]
    k8s_client_key: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateLdapInput {
    #[schemars(description = "Bind DN")]
    bind_dn: String,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: String,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Set Ldap server type, Options:[OpenLDAP, ActiveDirectory]")]
    server_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateLetsEncryptInput {
    acme_challenge: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Name of existing cloud target for DNS credentials. Required when acme-challenge=dns. Supported: AWS, Azure, GCP targets")]
    dns_target_creds: Option<String>,
    #[schemars(description = "Email address for ACME account registration")]
    email: Option<String>,
    #[schemars(description = "GCP Cloud DNS: Project ID. Optional - can be derived from service account")]
    gcp_project: Option<String>,
    #[schemars(description = "AWS Route53 hosted zone ID. Required when dns-target-creds points to AWS target")]
    hosted_zone: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    lets_encrypt_url: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Azure resource group name. Required when dns-target-creds points to Azure target")]
    resource_group: Option<String>,
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateLinkedInput {
    #[schemars(description = "A comma seperated list of new server hosts and server descriptions joined by semicolon ';' that will be added to the Linked Target hosts.")]
    add_hosts: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of server hosts and server descriptions joined by semicolon ';' (i.e. 'server-dev.com;My Dev server,server-prod.com;My Prod server description')")]
    hosts: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "Linked Target name")]
    name: String,
    #[schemars(description = "New Linked Target name")]
    new_name: Option<String>,
    #[schemars(description = "The parent Target name")]
    parent_target_name: Option<String>,
    #[schemars(description = "Comma separated list of existing hosts that will be removed from Linked Target hosts.")]
    rm_hosts: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Specifies the hosts type, relevant only when working without parent target")]
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateOpenAiInput {
    #[schemars(description = "API key for OpenAI")]
    api_key: Option<String>,
    #[schemars(description = "API key ID")]
    api_key_id: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Default model to use with OpenAI")]
    model: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_comment: Option<String>,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Base URL of the OpenAI API")]
    openai_url: Option<String>,
    #[schemars(description = "Organization ID")]
    organization_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdatePingInput {
    #[schemars(description = "Ping Federate administrative port")]
    administrative_port: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    authorization_port: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Ping Federate privileged user password")]
    password: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    privileged_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateRabbitMqInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    rabbitmq_server_password: Option<String>,
    rabbitmq_server_uri: Option<String>,
    rabbitmq_server_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateSalesforceInput {
    #[schemars(description = "Base64 encoded PEM of the connected app private key (relevant for JWT auth only)")]
    app_private_key_data: Option<String>,
    #[schemars(description = "type of the auth flow ('jwt' / 'user-password')")]
    auth_flow: String,
    #[schemars(description = "Base64 encoded PEM cert to use when uploading a new key to Salesforce")]
    ca_cert_data: Option<String>,
    #[schemars(description = "name of the certificate in Salesforce tenant to use when uploading new key")]
    ca_cert_name: Option<String>,
    #[schemars(description = "Client ID of the oauth2 app to use for connecting to Salesforce")]
    client_id: String,
    #[schemars(description = "Client secret of the oauth2 app to use for connecting to Salesforce (required for password flow)")]
    client_secret: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "The email of the user attached to the oauth2 app used for connecting to Salesforce")]
    email: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "The password of the user attached to the oauth2 app used for connecting to Salesforce (required for user-password flow)")]
    password: Option<String>,
    #[schemars(description = "The security token of the user attached to the oauth2 app used for connecting to Salesforce  (required for user-password flow)")]
    security_token: Option<String>,
    #[schemars(description = "Url of the Salesforce tenant")]
    tenant_url: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateSectigoInput {
    #[schemars(description = "Certificate Profile ID in Sectigo account")]
    certificate_profile_id: i64,
    #[schemars(description = "Customer Uri of the Sectigo account")]
    customer_uri: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "External Requester - a comma separated list of emails")]
    external_requester: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Organization ID in Sectigo account")]
    organization_id: i64,
    #[schemars(description = "Password of the Sectigo account user")]
    password: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Username of the Sectigo account")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateSshInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "SSH host name")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "SSH port")]
    port: Option<String>,
    #[schemars(description = "SSH private key")]
    private_key: Option<String>,
    #[schemars(description = "SSH private key password")]
    private_key_password: Option<String>,
    #[schemars(description = "SSH password to rotate")]
    ssh_password: Option<String>,
    #[schemars(description = "SSH username")]
    ssh_username: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateWebInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The url")]
    url: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateWindowsInput {
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    certificate: Option<String>,
    #[schemars(description = "Type of connection to Windows Server [credentials/parent-target]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "User domain name")]
    domain: Option<String>,
    #[schemars(description = "Server hostname")]
    hostname: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    #[schemars(description = "Privileged user password")]
    password: String,
    #[schemars(description = "Server WinRM port")]
    port: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Enable/Disable TLS for WinRM over HTTPS [true/false]")]
    use_tls: Option<String>,
    #[schemars(description = "Privileged username")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TargetUpdateZeroSslInput {
    #[schemars(description = "API Key of the ZeroSSLTarget account")]
    api_key: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapValidationEmail to use when asking ZeroSSL to send a validation email, if empty will user imap-username")]
    imap_target_email: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct TokenizeInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Data to be encrypted")]
    plaintext: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The name of the tokenizer to use in the encryption process")]
    tokenizer_name: String,
    #[schemars(description = "Base64 encoded tweak for vaultless encryption")]
    tweak: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UidCreateChildTokenInput {
    #[schemars(description = "The universal identity auth method name, required only when uid-token is not provided")]
    auth_method_name: Option<String>,
    #[schemars(description = "Deny from new child to create their own children")]
    child_deny_inheritance: Option<bool>,
    #[schemars(description = "Deny from new child to rotate")]
    child_deny_rotate: Option<bool>,
    #[schemars(description = "New child token ttl")]
    child_ttl: Option<i64>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The ID of the uid-token, required only when uid-token is not provided")]
    uid_token_id: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UidGenerateTokenInput {
    #[schemars(description = "The universal identity auth method name")]
    auth_method_name: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UidListChildrenInput {
    #[schemars(description = "The universal identity auth method name, required only when uid-token is not provided")]
    auth_method_name: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UidRevokeTokenInput {
    #[schemars(description = "The universal identity auth method name")]
    auth_method_name: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "the universal identity token/token-id to revoke")]
    revoke_token: String,
    #[schemars(description = "revokeSelf/revokeAll (delete only this token/this token and his children)")]
    revoke_type: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UidRotateTokenInput {
    #[schemars(description = "Create a new child token with default parameters")]
    fork: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The new rotated token to send manual ack for (with uid-token=the-orig-token)")]
    send_manual_ack_token: Option<String>,
    #[schemars(description = "The Universal identity token")]
    uid_token: Option<String>,
    #[schemars(description = "Disable automatic ack")]
    with_manual_ack: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UnwrapTokenInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The shared token")]
    shared_token: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAccountSettingsInput {
    #[schemars(description = "Address")]
    address: Option<String>,
    #[schemars(description = "A default list of client types that are allowed to authenticate [cli,ui,gateway-admin,sdk,mobile,extension].")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Limits email sharing to the specified domains. Relevant only when item sharing is enabled. By default, all domains are allowed.")]
    allowed_email_domains: Option<Vec<String>>,
    #[schemars(description = "A default list of comma-separated CIDR block that are allowed to authenticate.")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "City")]
    city: Option<String>,
    #[schemars(description = "Company name")]
    company_name: Option<String>,
    #[schemars(description = "Country")]
    country: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified. To specify multiple events, use argument multiple times: --default-certificate-expiration-notification-days 1 --default-certificate-expiration-notification-days 5")]
    default_certificate_expiration_notification_days: Option<Vec<String>>,
    #[schemars(description = "Set the account default key based on the DFC key name. Use \"set-original-akeyless-default-key\" to revert to using the original default key of the account.")]
    default_key_name: Option<String>,
    #[schemars(description = "Set the default ttl in minutes for sharing item number between 60 and 43200")]
    default_share_link_ttl_minutes: Option<String>,
    #[schemars(description = "If set to true, new versions is enabled by default")]
    default_versioning: Option<String>,
    #[schemars(description = "Set to update protection with classic keys state [true/false]")]
    dp_enable_classic_key_protection: Option<String>,
    #[schemars(description = "Set the maximum ttl for dynamic secrets")]
    dynamic_secret_max_ttl: Option<i64>,
    #[schemars(description = "Set a maximum ttl for dynamic secrets [true/false]")]
    dynamic_secret_max_ttl_enable: Option<String>,
    #[schemars(description = "Enable AI insights [true/false]")]
    enable_ai_insights: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified. [true/false]")]
    enable_default_certificate_expiration_event: Option<String>,
    #[schemars(description = "Enable sharing items [true/false]")]
    enable_item_sharing: Option<String>,
    #[schemars(description = "Enable password expiration policy [true/false]")]
    enable_password_expiration: Option<String>,
    #[schemars(description = "If set to true, new version will be created on update")]
    force_new_versions: Option<String>,
    #[schemars(description = "A default list of comma-separated CIDR block that acts as a trusted Gateway entity.")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Hide personal folder, if set - users will not be able to use personal folder [true/false]")]
    hide_personal_folder: Option<String>,
    #[schemars(description = "Hide static secret's password type [true/false]")]
    hide_static_password: Option<String>,
    #[schemars(description = "Characters that cannot be used for items/targets/roles/auths/event_forwarder names. Empty string will enforce nothing.")]
    invalid_characters: Option<String>,
    #[schemars(description = "VersionSettingsObjectType defines object types for account version settings")]
    item_type: Option<String>,
    #[schemars(description = "Set or unset the default behaviour of items deletion protection [true/false]")]
    items_deletion_protection: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Default ttl")]
    jwt_ttl_default: Option<i64>,
    #[schemars(description = "Maximum ttl")]
    jwt_ttl_max: Option<i64>,
    #[schemars(description = "Minimum ttl")]
    jwt_ttl_min: Option<i64>,
    #[schemars(description = "Lock allowed-client-type setting in the account [true/false].")]
    lock_allowed_client_type: Option<String>,
    #[schemars(description = "Lock bound-ips setting globally in the account.")]
    lock_bound_ips: Option<String>,
    #[schemars(description = "Lock the account's default protection key, if set - users will not be able to use a different protection key, relevant only if default-key-name is configured [true/false]")]
    lock_default_key: Option<String>,
    #[schemars(description = "Lock gw-bound-ips setting in the account.")]
    lock_gw_bound_ips: Option<String>,
    #[schemars(description = "Set the maximum rotation interval for rotated secrets auto rotation settings")]
    max_rotation_interval: Option<i64>,
    #[schemars(description = "Set a maximum rotation interval for rotated secrets auto rotation settings [true/false]")]
    max_rotation_interval_enable: Option<String>,
    #[schemars(description = "Max versions")]
    max_versions: Option<String>,
    #[schemars(description = "Specifies the number of days that a password is valid before it must be changed. A default value of 90 days is used.")]
    password_expiration_days: Option<String>,
    #[schemars(description = "Specifies the number of days before a user receives notification that their password will expire. A default value of 14 days is used.")]
    password_expiration_notification_days: Option<String>,
    #[schemars(description = "Password length between 5 - to 50 characters")]
    password_length: Option<i64>,
    #[schemars(description = "Phone number")]
    phone: Option<String>,
    #[schemars(description = "Postal code")]
    postal_code: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Enable event for objects that have not been used or changed [true/false]")]
    usage_event_enable: Option<String>,
    #[schemars(description = "Interval by days for unused objects. Default and minimum interval is 90 days")]
    usage_event_interval: Option<i64>,
    #[schemars(description = "Usage event is supported for auth method or secrets-and-keys [auth/item]")]
    usage_event_object_type: Option<String>,
    #[schemars(description = "Password must contain capital letters [true/false]")]
    use_capital_letters: Option<String>,
    #[schemars(description = "Password must contain lower case letters [true/false]")]
    use_lower_letters: Option<String>,
    #[schemars(description = "Password must contain numbers [true/false]")]
    use_numbers: Option<String>,
    #[schemars(description = "Password must contain special characters [true/false]")]
    use_special_characters: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateArtifactoryTargetInput {
    #[schemars(description = "Artifactory Admin Name")]
    artifactory_admin_name: String,
    #[schemars(description = "Artifactory Admin password")]
    artifactory_admin_pwd: String,
    #[schemars(description = "Base URL")]
    base_url: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAssocInput {
    #[schemars(description = "The association id to be updated")]
    assoc_id: String,
    #[schemars(description = "Treat sub claims as case-sensitive [true/false]")]
    case_sensitive: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "key/val of sub claims, e.g group=admins,developers")]
    sub_claims: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodAwsiamInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of full arns that the access is restricted to")]
    bound_arn: Option<Vec<String>>,
    #[schemars(description = "A list of AWS account-IDs that the access is restricted to")]
    bound_aws_account_id: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role ids that the access is restricted to")]
    bound_role_id: Option<Vec<String>>,
    #[schemars(description = "A list of full role-name that the access is restricted to")]
    bound_role_name: Option<Vec<String>>,
    #[schemars(description = "A list of full user ids that the access is restricted to")]
    bound_user_id: Option<Vec<String>>,
    #[schemars(description = "A list of full user-name that the access is restricted to")]
    bound_user_name: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "sts URL")]
    sts_url: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodAzureAdInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Deprecated (Deprecated) The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of group ids that the access is restricted to")]
    bound_group_id: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of resource providers that the access is restricted to (e.g, Microsoft.Compute, Microsoft.ManagedIdentity, etc)")]
    bound_providers: Option<Vec<String>>,
    #[schemars(description = "A list of full resource ids that the access is restricted to")]
    bound_resource_id: Option<Vec<String>>,
    #[schemars(description = "A list of resource names that the access is restricted to (e.g, a virtual machine name, scale set name, etc).")]
    bound_resource_names: Option<Vec<String>>,
    #[schemars(description = "A list of resource types that the access is restricted to (e.g, virtualMachines, userAssignedIdentities, etc)")]
    bound_resource_types: Option<Vec<String>>,
    #[schemars(description = "A list of resource groups that the access is restricted to")]
    bound_rg_id: Option<Vec<String>>,
    #[schemars(description = "A list of service principal IDs that the access is restricted to")]
    bound_spid: Option<Vec<String>>,
    #[schemars(description = "A list of subscription ids that the access is restricted to")]
    bound_sub_id: Option<Vec<String>>,
    #[schemars(description = "The Azure tenant id that the access is restricted to")]
    bound_tenant_id: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodCertInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Comma separated list of allowed CORS domains to be validated as part of the authentication flow.")]
    allowed_cors: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A list of names. At least one must exist in the Common Name. Supports globbing.")]
    bound_common_names: Option<Vec<String>>,
    #[schemars(description = "A list of DNS names. At least one must exist in the SANs. Supports globbing.")]
    bound_dns_sans: Option<Vec<String>>,
    #[schemars(description = "A list of Email Addresses. At least one must exist in the SANs. Supports globbing.")]
    bound_email_sans: Option<Vec<String>>,
    #[schemars(description = "A list of extensions formatted as \"oid:value\". Expects the extension value to be some type of ASN1 encoded string. All values much match. Supports globbing on \"value\".")]
    bound_extensions: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of Organizational Units names. At least one must exist in the OU field.")]
    bound_organizational_units: Option<Vec<String>>,
    #[schemars(description = "A list of URIs. At least one must exist in the SANs. Supports globbing.")]
    bound_uri_sans: Option<Vec<String>>,
    #[schemars(description = "The certificate data in base64, if no file was provided")]
    certificate_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Require certificate CRL distribution points (CDP) and enforce CRL validation during authentication.")]
    require_crl_dp: Option<bool>,
    #[schemars(description = "A list of revoked cert ids")]
    revoked_cert_ids: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured, such as common_name or organizational_unit Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodGcpInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience to verify in the JWT received by the client")]
    audience: String,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A comma-separated list of GCP labels formatted as \"key:value\" strings that must be set on authorized GCE instances. TODO: Because GCP labels are not currently ACL'd ....")]
    bound_labels: Option<Vec<String>>,
    #[schemars(description = "=== Human and Machine authentication section === Array of GCP project IDs. Only entities belonging to any of the provided projects can authenticate.")]
    bound_projects: Option<Vec<String>>,
    #[schemars(description = "List of regions that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a regional group and the group must belong to this region. If bound_zones are provided, this attribute is ignored.")]
    bound_regions: Option<Vec<String>>,
    #[schemars(description = "List of service accounts the service account must be part of in order to be authenticated.")]
    bound_service_accounts: Option<Vec<String>>,
    #[schemars(description = "=== Machine authentication section === List of zones that a GCE instance must belong to in order to be authenticated. TODO: If bound_instance_groups is provided, it is assumed to be a zonal group and the group must belong to this zone.")]
    bound_zones: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "ServiceAccount credentials data instead of giving a file path, base64 encoded")]
    service_account_creds_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Type of the GCP Access Rules")]
    type: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value which is a \"sub claim\" name that contains details uniquely identifying that resource. This \"sub claim\" is used to distinguish between different identities.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodK8sInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the Kubernetes JWT that the access is restricted to")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "A list of namespaces that the access is restricted to")]
    bound_namespaces: Option<Vec<String>>,
    #[schemars(description = "A list of pod names that the access is restricted to")]
    bound_pod_names: Option<Vec<String>>,
    #[schemars(description = "A list of service account names that the access is restricted to")]
    bound_sa_names: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for K8S configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Base64-encoded or PEM formatted public key data for K8S authentication method is required [RSA2048]")]
    public_key: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodLdapInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Automatically generate key-pair for LDAP configuration. If set to false, a public key needs to be provided [true/false]")]
    gen_key: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A public key generated for LDAP authentication method on Akeyless in base64 or PEM format [RSA2048]")]
    public_key_data: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodOAuth2Input {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "The audience in the JWT")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "The clients ids that the access is restricted to")]
    bound_client_ids: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "CertificateFile Path to a file that contain the certificate in a PEM format.")]
    cert: Option<String>,
    #[schemars(description = "CertificateFileData PEM Certificate in a Base64 format.")]
    cert_file_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "Akeyless Gateway URL (Configuration Management port). Relevant only when the jwks-uri is accessible only from the gateway.")]
    gateway_url: Option<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server. base64 encoded string")]
    jwks_json_data: Option<String>,
    #[schemars(description = "The URL to the JSON Web Key Set (JWKS) that containing the public keys that should be used to verify any JSON Web Token (JWT) issued by the authorization server.")]
    jwks_uri: Option<String>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodOciInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A list of required groups ocids")]
    group_ocid: Vec<String>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "The Oracle Cloud tenant ID")]
    tenant_ocid: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodOidcInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Audience claim to be used as part of the authentication flow. In case set, it must match the one configured on the Identity Provider's Application")]
    audience: Option<String>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Client ID")]
    client_id: Option<String>,
    #[schemars(description = "Client Secret")]
    client_secret: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Issuer URL")]
    issuer: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "RequiredScopes is a list of required scopes that the oidc method will request from the oidc provider and the user must approve")]
    required_scopes: Option<Vec<String>>,
    #[schemars(description = "RequiredScopesPrefix is a a prefix to add to all required-scopes when requesting them from the oidc server (for example, azures' Application ID URI)")]
    required_scopes_prefix: Option<String>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OIDC, OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodSamlInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Allowed redirect URIs after the authentication")]
    allowed_redirect_uri: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "IDP metadata url")]
    idp_metadata_url: Option<String>,
    #[schemars(description = "IDP metadata xml data")]
    idp_metadata_xml_data: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "A list of additional sub claims delimiters (relevant only for SAML, OIDC, OAuth2/JWT)")]
    subclaims_delimiters: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A unique identifier (ID) value should be configured for OAuth2, LDAP and SAML authentication method types and is usually a value such as the email, username, or upn for example. Whenever a user logs in with a token, these authentication types issue a \"sub claim\" that contains details uniquely identifying that user. This sub claim includes a key containing the ID value that you configured, and is used to distinguish between different users from within the same organization.")]
    unique_identifier: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAuthMethodUniversalIdentityInput {
    #[schemars(description = "Access expiration date in Unix timestamp (select 0 for access without expiry date)")]
    access_expires: Option<i64>,
    #[schemars(description = "limit the auth method usage for specific client types [cli,ui,gateway-admin,sdk,mobile,extension]")]
    allowed_client_type: Option<Vec<String>>,
    #[schemars(description = "Subclaims to include in audit logs, e.g \"--audit-logs-claims email --audit-logs-claims username\"")]
    audit_logs_claims: Option<Vec<String>>,
    #[schemars(description = "A CIDR whitelist with the IPs that the access is restricted to")]
    bound_ips: Option<Vec<String>>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Deny from root to create children")]
    deny_inheritance: Option<bool>,
    #[schemars(description = "Deny from the token to rotate")]
    deny_rotate: Option<bool>,
    #[schemars(description = "Auth Method description")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the auth method would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "if true: enforce role-association must include sub claims")]
    force_sub_claims: Option<bool>,
    #[schemars(description = "A CIDR whitelist with the GW IPs that the access is restricted to")]
    gw_bound_ips: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Jwt TTL")]
    jwt_ttl: Option<i64>,
    #[schemars(description = "Auth Method name")]
    name: String,
    #[schemars(description = "Auth Method new name")]
    new_name: Option<String>,
    #[schemars(description = "Choose the relevant product type for the auth method [sm, sra, pm, dp, ca]")]
    product_type: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token ttl")]
    ttl: Option<i64>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAwsTargetInput {
    #[schemars(description = "AWS secret access key")]
    access_key: String,
    #[schemars(description = "AWS access key ID")]
    access_key_id: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A unique auto-generated value used in your AWS account when configuring your AWS IAM role to securely delegate access to Akeyless. Relevant only when using GW cloud ID")]
    generate_external_id: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "AWS region")]
    region: Option<String>,
    #[schemars(description = "AWS IAM role identifier that Gateway will assume in your AWS account, relevant only when using external ID")]
    role_arn: Option<String>,
    #[schemars(description = "Required only for temporary security credentials retrieved using STS")]
    session_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    #[schemars(description = "Use the GW's Cloud IAM")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAwsTargetDetailsInput {
    #[schemars(description = "The aws secret access key")]
    access_key: Option<String>,
    #[schemars(description = "The aws access key id")]
    access_key_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "The aws region")]
    region: Option<String>,
    #[schemars(description = "Required only for temporary security credentials retrieved via STS, otherwise it can be an empty string")]
    session_token: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateAzureTargetInput {
    #[schemars(description = "Azure cloud environment to use. Values: AzureCloud (default), AzureUSGovernment, AzureChinaCloud.")]
    azure_cloud: Option<String>,
    #[schemars(description = "Azure client/application id")]
    client_id: Option<String>,
    #[schemars(description = "Azure client secret")]
    client_secret: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Type of connection [credentials/cloud-identity]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "The Resource Group name in your Azure subscription")]
    resource_group_name: Option<String>,
    #[schemars(description = "The name of the relevant Resource")]
    resource_name: Option<String>,
    #[schemars(description = "Azure Subscription Id")]
    subscription_id: Option<String>,
    #[schemars(description = "Azure tenant id")]
    tenant_id: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    #[schemars(description = "Use the GW's Cloud IAM [Deprecated: Use connection-type=cloud-identity]")]
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateCertificateValueInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "Content of the certificate in a Base64 format.")]
    certificate_data: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "CertificateFormat of the certificate and private key, possible values: cer,crt,pem,pfx,p12. Required when passing inline certificate content with --certificate-data or --key-data, otherwise format is derived from the file extension.")]
    format: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key to use to encrypt the certificate's key (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Content of the certificate's private key in a Base64 format.")]
    key_data: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "Certificate name")]
    name: String,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateClassicKeyCertificateInput {
    #[schemars(description = "PEM Certificate in a Base64 format. Used for updating RSA keys' certificates.")]
    cert_file_data: Option<String>,
    certificate_format: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "ClassicKey name")]
    name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateDbTargetInput {
    #[schemars(description = "(Optional) Client id (relevant for \"cloud-service-provider\" only)")]
    azure_client_id: Option<String>,
    #[schemars(description = "(Optional) Client secret (relevant for \"cloud-service-provider\" only)")]
    azure_client_secret: Option<String>,
    #[schemars(description = "(Optional) Tenant id (relevant for \"cloud-service-provider\" only)")]
    azure_tenant_id: Option<String>,
    #[schemars(description = "(Optional) Cloud service provider (currently only supports Azure)")]
    cloud_service_provider: Option<String>,
    #[schemars(description = "Cluster Mode")]
    cluster_mode: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Type of connection to mssql database [credentials/cloud-identity/wallet/parent-target]")]
    connection_type: String,
    db_name: Option<String>,
    #[schemars(description = "(Optional) DB server certificates")]
    db_server_certificates: Option<String>,
    #[schemars(description = "(Optional) Server name for certificate verification")]
    db_server_name: Option<String>,
    db_type: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    mongodb_atlas: Option<bool>,
    #[schemars(description = "MongoDB Atlas private key")]
    mongodb_atlas_api_private_key: Option<String>,
    #[schemars(description = "MongoDB Atlas public key")]
    mongodb_atlas_api_public_key: Option<String>,
    #[schemars(description = "MongoDB Atlas project ID")]
    mongodb_atlas_project_id: Option<String>,
    #[schemars(description = "MongoDB server default authentication database")]
    mongodb_default_auth_db: Option<String>,
    #[schemars(description = "MongoDB server URI options")]
    mongodb_uri_options: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Oracle db service name")]
    oracle_service_name: Option<String>,
    #[schemars(description = "Oracle Wallet login type (password/mtls)")]
    oracle_wallet_login_type: Option<String>,
    #[schemars(description = "Oracle wallet p12 file data in base64")]
    oracle_wallet_p12_file_data: Option<String>,
    #[schemars(description = "Oracle wallet sso file data in base64")]
    oracle_wallet_sso_file_data: Option<String>,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    port: Option<String>,
    pwd: Option<String>,
    snowflake_account: Option<String>,
    #[schemars(description = "RSA Private key (base64 encoded)")]
    snowflake_api_private_key: Option<String>,
    #[schemars(description = "The Private key passphrase")]
    snowflake_api_private_key_password: Option<String>,
    #[schemars(description = "Enable/Disable SSL [true/false]")]
    ssl: Option<bool>,
    #[schemars(description = "SSL connection certificate")]
    ssl_certificate: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    user_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateDbTargetDetailsInput {
    db_type: Option<String>,
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    mongo_db_name: Option<String>,
    mongo_uri: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    port: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    pwd: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    user_name: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateDockerhubTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Password for docker repository")]
    dockerhub_password: Option<String>,
    #[schemars(description = "Username for docker repository")]
    dockerhub_username: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateEksTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Access Key ID")]
    eks_access_key_id: String,
    #[schemars(description = "EKS cluster CA certificate")]
    eks_cluster_ca_cert: String,
    #[schemars(description = "EKS cluster URL endpoint")]
    eks_cluster_endpoint: String,
    #[schemars(description = "EKS cluster name")]
    eks_cluster_name: String,
    #[schemars(description = "Region")]
    eks_region: Option<String>,
    #[schemars(description = "Secret Access Key")]
    eks_secret_access_key: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateEventForwarderInput {
    #[schemars(description = "Workstation Admin Name")]
    admin_name: Option<String>,
    #[schemars(description = "The authentication type to use when connecting to ServiceNow (user-pass / jwt)")]
    auth_type: Option<String>,
    #[schemars(description = "The client ID to use when connecting to ServiceNow with jwt authentication")]
    client_id: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of email addresses to send event to (relevant only for \"email\" Event Forwarder)")]
    email_to: Option<String>,
    #[schemars(description = "Enable/Disable Event Forwarder [true/false]")]
    enable: Option<String>,
    #[schemars(description = "Event sources")]
    event_source_locations: Option<Vec<String>>,
    #[schemars(description = "Event types")]
    event_types: Option<Vec<String>>,
    #[schemars(description = "Workstation Host")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "EventForwarder name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_comment: Option<String>,
    #[schemars(description = "New EventForwarder name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The user email to use when connecting to ServiceNow with jwt authentication")]
    user_email: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGcpTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGithubTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Github app id")]
    github_app_id: Option<i64>,
    #[schemars(description = "App private key")]
    github_app_private_key: Option<String>,
    #[schemars(description = "Base URL")]
    github_base_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGitlabTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Gitlab access token")]
    gitlab_access_token: Option<String>,
    #[schemars(description = "Gitlab tls certificate (base64 encoded)")]
    gitlab_certificate: Option<String>,
    #[schemars(description = "Gitlab base url")]
    gitlab_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGkeTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "GKE Service Account key file path")]
    gke_account_key: Option<String>,
    #[schemars(description = "GKE cluster CA certificate")]
    gke_cluster_cert: Option<String>,
    #[schemars(description = "GKE cluster URL endpoint")]
    gke_cluster_endpoint: Option<String>,
    #[schemars(description = "GKE cluster name")]
    gke_cluster_name: Option<String>,
    #[schemars(description = "GKE service account email")]
    gke_service_account_email: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    use_gw_cloud_identity: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGlobalSignAtlasTargetInput {
    #[schemars(description = "API Key of the GlobalSign Atlas account")]
    api_key: String,
    #[schemars(description = "API Secret of the GlobalSign Atlas account")]
    api_secret: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Mutual TLS Certificate contents of the GlobalSign Atlas account encoded in base64, either mtls-cert-file-path or mtls-cert-data-base64 must be supplied")]
    mtls_cert_data_base64: Option<String>,
    #[schemars(description = "Mutual TLS Key contents of the GlobalSign Atlas account encoded in base64, either mtls-key-file-path or mtls-data-base64 must be supplied")]
    mtls_key_data_base64: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGlobalSignTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Email of the GlobalSign GCC account contact")]
    contact_email: String,
    #[schemars(description = "First name of the GlobalSign GCC account contact")]
    contact_first_name: String,
    #[schemars(description = "Last name of the GlobalSign GCC account contact")]
    contact_last_name: String,
    #[schemars(description = "Telephone of the GlobalSign GCC account contact")]
    contact_phone: String,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Password of the GlobalSign GCC account")]
    password: String,
    #[schemars(description = "Profile ID of the GlobalSign GCC account")]
    profile_id: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    #[schemars(description = "Username of the GlobalSign GCC account")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGodaddyTargetInput {
    #[schemars(description = "Key of the api credentials to the Godaddy account")]
    api_key: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Customer ID (ShopperId) required for renewal of imported certificates")]
    customer_id: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Secret of the api credentials to the Godaddy account")]
    secret: String,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateGroupInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A short group alias")]
    group_alias: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Group name")]
    name: String,
    #[schemars(description = "Group new name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "A json string defining the access permission assignment for this client")]
    user_assignment: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateHashiVaultTargetInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "HashiCorp Vault API URL, e.g. https://vault-mgr01:8200")]
    hashi_url: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Comma-separated list of vault namespaces")]
    namespace: Option<Vec<String>>,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    #[schemars(description = "Vault access token with sufficient permissions")]
    vault_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateItemInput {
    provider_type: Option<String>,
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "PEM Certificate in a Base64 format. Used for updating RSA keys' certificates.")]
    cert_file_data: Option<String>,
    certificate_format: Option<String>,
    #[schemars(description = "Trigger an event when a secret value changed [true/false] (Relevant only for Static Secret)")]
    change_event: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "GCP Secret Manager regions to query for regional secrets (comma-separated, e.g., us-east1,us-west1). Max 12 regions. USC with GCP targets only.")]
    gcp_sm_regions: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Current item name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_metadata: Option<String>,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "List of the new hosts that will be attached to SRA servers host")]
    secure_access_add_host: Option<Vec<String>>,
    #[schemars(description = "Allow providing external user for a domain users [true/false]")]
    secure_access_allow_external_user: Option<String>,
    #[schemars(description = "Enable Port forwarding while using CLI access (relevant only for EKS/GKE/K8s Dynamic-Secret)")]
    secure_access_allow_port_forwading: Option<bool>,
    #[schemars(description = "Bastion's SSH control API endpoint. E.g. https://my.sra-server:9900 (relevant only for ssh cert issuer)")]
    secure_access_api: Option<String>,
    #[schemars(description = "The AWS account id (relevant only for aws)")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli (relevant only for aws)")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "The AWS region (relevant only for aws)")]
    secure_access_aws_region: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-api")]
    secure_access_bastion_api: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-ssh")]
    secure_access_bastion_ssh: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The K8s cluster endpoint URL (relevant only for EKS/GKE/K8s Dynamic-Secret)")]
    secure_access_cluster_endpoint: Option<String>,
    #[schemars(description = "The K8s dashboard url (relevant only for k8s)")]
    secure_access_dashboard_url: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The DB schema (relevant only for DB Dynamic-Secret)")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    secure_access_gateway: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "RD Gateway server (relevant only for rdp)")]
    secure_access_rd_gateway_server: Option<String>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user (relevant only for RDP Dynamic-Secret)")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "List of the existent hosts that will be removed from SRA servers host")]
    secure_access_rm_host: Option<Vec<String>>,
    #[schemars(description = "Bastion's SSH server. E.g. my.sra-server:22 (relevant only for ssh cert issuer)")]
    secure_access_ssh: Option<String>,
    #[schemars(description = "Secret values contains SSH Credentials, either Private Key or Password [password/private-key] (relevant only for Static-Secret or Rotated-secret)")]
    secure_access_ssh_creds: Option<String>,
    #[schemars(description = "SSH username to connect to target server, must be in 'Allowed Users' list (relevant only for ssh cert issuer)")]
    secure_access_ssh_creds_user: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Deprecated. Use secure-access-use-internal-ssh-access")]
    secure_access_use_internal_bastion: Option<bool>,
    #[schemars(description = "Use internal SSH Access")]
    secure_access_use_internal_ssh_access: Option<bool>,
    #[schemars(description = "Secure browser via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateNativeK8sTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "K8S auth type [token/certificate]")]
    k8s_auth_type: Option<String>,
    #[schemars(description = "Content of the k8 client certificate (PEM format) in a Base64 format")]
    k8s_client_certificate: Option<String>,
    #[schemars(description = "Content of the k8 client private key (PEM format) in a Base64 format")]
    k8s_client_key: Option<String>,
    #[schemars(description = "K8S cluster CA certificate")]
    k8s_cluster_ca_cert: Option<String>,
    #[schemars(description = "K8S cluster URL endpoint")]
    k8s_cluster_endpoint: Option<String>,
    #[schemars(description = "K8S cluster name")]
    k8s_cluster_name: Option<String>,
    #[schemars(description = "K8S cluster Bearer token")]
    k8s_cluster_token: Option<String>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    #[schemars(description = "Use the GW's service account")]
    use_gw_service_account: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateLdapTargetInput {
    #[schemars(description = "Bind DN")]
    bind_dn: String,
    #[schemars(description = "Bind DN Password")]
    bind_dn_password: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "CA Certificate File Content")]
    ldap_ca_cert: Option<String>,
    #[schemars(description = "LDAP Server URL")]
    ldap_url: String,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Set Ldap server type, Options:[OpenLDAP, ActiveDirectory]")]
    server_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Token expiration")]
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateLdapTargetDetailsInput {
    bind_dn: Option<String>,
    bind_dn_password: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    key: Option<String>,
    ldap_ca_cert: Option<String>,
    ldap_url: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    token_expiration: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateLinkedTargetInput {
    #[schemars(description = "A comma seperated list of new server hosts and server descriptions joined by semicolon ';' that will be added to the Linked Target hosts.")]
    add_hosts: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A comma seperated list of server hosts and server descriptions joined by semicolon ';' (i.e. 'server-dev.com;My Dev server,server-prod.com;My Prod server description')")]
    hosts: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "Linked Target name")]
    name: String,
    #[schemars(description = "New Linked Target name")]
    new_name: Option<String>,
    #[schemars(description = "The parent Target name")]
    parent_target_name: Option<String>,
    #[schemars(description = "Comma separated list of existing hosts that will be removed from Linked Target hosts.")]
    rm_hosts: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "Specifies the hosts type, relevant only when working without parent target")]
    type: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateOidcAppInput {
    #[schemars(description = "A comma separated list of allowed audiences")]
    audience: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the OIDC application (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "OIDC application name")]
    name: String,
    #[schemars(description = "A json string defining the access permission assignment for this app")]
    permission_assignment: Option<String>,
    #[schemars(description = "Set to true if the app is public (cannot keep secrets)")]
    public: Option<bool>,
    #[schemars(description = "A comma separated list of allowed redirect uris")]
    redirect_uris: Option<String>,
    #[schemars(description = "A comma separated list of allowed scopes")]
    scopes: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdatePingTargetInput {
    #[schemars(description = "Ping Federate administrative port")]
    administrative_port: Option<String>,
    #[schemars(description = "Ping Federate authorization port")]
    authorization_port: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Ping Federate privileged user password")]
    password: Option<String>,
    #[schemars(description = "Ping URL")]
    ping_url: Option<String>,
    #[schemars(description = "Ping Federate privileged user")]
    privileged_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdatePkiCertIssuerInput {
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "If set, clients can request certificates for any CN")]
    allow_any_name: Option<bool>,
    #[schemars(description = "If set, will allow copying the extra extensions from the csr file (if given)")]
    allow_copy_ext_from_csr: Option<bool>,
    #[schemars(description = "If set, clients can request certificates for subdomains of the allowed domains")]
    allow_subdomains: Option<bool>,
    #[schemars(description = "A list of the allowed domains that clients can request to be included in the certificate (in a comma-delimited list)")]
    allowed_domains: Option<String>,
    #[schemars(description = "A json string containing the allowed extra extensions for the pki cert issuer")]
    allowed_extra_extensions: Option<String>,
    #[schemars(description = "A list of the allowed CIDRs for ips that clients can request to be included in the certificate as part of the IP Subject Alternative Names (in a comma-delimited list)")]
    allowed_ip_sans: Option<String>,
    #[schemars(description = "A list of the allowed URIs that clients can request to be included in the certificate as part of the URI Subject Alternative Names (in a comma-delimited list)")]
    allowed_uri_sans: Option<String>,
    #[schemars(description = "Automatically renew certificates before expiration")]
    auto_renew: Option<bool>,
    #[schemars(description = "If set, certificates will be flagged for client auth use")]
    client_flag: Option<bool>,
    #[schemars(description = "If set, certificates will be flagged for code signing use")]
    code_signing_flag: Option<bool>,
    #[schemars(description = "A comma-separated list of countries that will be set in the issued certificate")]
    country: Option<String>,
    #[schemars(description = "Set this to allow the issuer will expose a CRL endpoint in the Gateway")]
    create_private_crl: Option<bool>,
    #[schemars(description = "Set this to enable an OCSP endpoint in the Gateway and include its URL in AIA")]
    create_private_ocsp: Option<bool>,
    #[schemars(description = "Set this to allow the cert issuer will expose a public CRL endpoint")]
    create_public_crl: Option<bool>,
    #[schemars(description = "Set this to enable a public OCSP endpoint and include its URL in AIA (served by UAM and includes account id)")]
    create_public_ocsp: Option<bool>,
    #[schemars(description = "Mark key usage as critical [true/false]")]
    critical_key_usage: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "A path in which to save generated certificates")]
    destination_path: Option<String>,
    #[schemars(description = "If set, generation of wildcard certificates will be disabled.")]
    disable_wildcards: Option<bool>,
    #[schemars(description = "If set, the cert issuer will support the acme protocol")]
    enable_acme: Option<bool>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "The GW cluster URL to issue the certificate from. Required in Public CA mode, to allow CRLs on private CA, or to enable ACME")]
    gw_cluster_url: Option<String>,
    #[schemars(description = "If set, the basic constraints extension will be added to certificate")]
    is_ca: Option<bool>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "key-usage")]
    key_usage: Option<String>,
    #[schemars(description = "A comma-separated list of localities that will be set in the issued certificate")]
    locality: Option<String>,
    #[schemars(description = "The maximum path length for the generated certificate. -1, means unlimited")]
    max_path_len: Option<i64>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "PKI certificate issuer name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "If set, any names are allowed for CN and SANs in the certificate and not only a valid host name")]
    not_enforce_hostnames: Option<bool>,
    #[schemars(description = "If set, clients can request certificates without a CN")]
    not_require_cn: Option<bool>,
    #[schemars(description = "OCSP NextUpdate window for OCSP responses (min 10m). Supports s,m,h,d suffix.")]
    ocsp_ttl: Option<String>,
    #[schemars(description = "A comma-separated list of organizational units (OU) that will be set in the issued certificate")]
    organizational_units: Option<String>,
    #[schemars(description = "A comma-separated list of organizations (O) that will be set in the issued certificate")]
    organizations: Option<String>,
    #[schemars(description = "A comma-separated list of postal codes that will be set in the issued certificate")]
    postal_code: Option<String>,
    #[schemars(description = "Whether to protect generated certificates from deletion")]
    protect_certificates: Option<bool>,
    #[schemars(description = "A comma-separated list of provinces that will be set in the issued certificate")]
    province: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Number of days before expiration to renew certificates")]
    scheduled_renew: Option<i64>,
    #[schemars(description = "If set, certificates will be flagged for server auth use")]
    server_flag: Option<bool>,
    #[schemars(description = "A key to sign the certificate with, required in Private CA mode")]
    signer_key_name: Option<String>,
    #[schemars(description = "A comma-separated list of street addresses that will be set in the issued certificate")]
    street_address: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The maximum requested Time To Live for issued certificates, in seconds. In case of Public CA, this is based on the CA target's supported maximum TTLs")]
    ttl: String,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateRabbitMqTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    rabbitmq_server_password: Option<String>,
    rabbitmq_server_uri: Option<String>,
    rabbitmq_server_user: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateRabbitMqTargetDetailsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    pwd: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    uri: Option<String>,
    user: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateRdpTargetDetailsInput {
    #[schemars(description = "The admin name")]
    admin_name: Option<String>,
    #[schemars(description = "The admin password")]
    admin_pwd: Option<String>,
    #[schemars(description = "The rdp host name")]
    host_name: Option<String>,
    #[schemars(description = "The rdp port")]
    host_port: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateRoleInput {
    #[schemars(description = "Allow this role to view analytics. Currently only 'none', 'own', 'all' values are supported, allowing associated auth methods to view reports produced by the same auth methods.")]
    analytics_access: Option<String>,
    #[schemars(description = "Allow this role to view audit logs. Currently only 'none', 'own', 'scoped' and 'all' values are supported, allowing associated auth methods to view audit logs produced by the same auth methods.")]
    audit_access: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Allow this role to view Event Center. Currently only 'none', 'scoped' and 'all' values are supported")]
    event_center_access: Option<String>,
    #[schemars(description = "Allow this role to manage Event Forwarders. Currently only 'none' and 'all' values are supported.")]
    event_forwarder_access: Option<String>,
    #[schemars(description = "Allow this role to view gw analytics. Currently only 'none', 'scoped', 'all' values are supported, allowing associated auth methods to view reports produced by the same auth methods.")]
    gw_analytics_access: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Role name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_comment: Option<String>,
    #[schemars(description = "New Role name")]
    new_name: Option<String>,
    #[schemars(description = "Allow this role to view Reverse RBAC. Supported values: 'scoped', 'all'.")]
    reverse_rbac_access: Option<String>,
    #[schemars(description = "Allow this role to view SRA Clusters. Currently only 'none', 'scoped', 'all' values are supported.")]
    sra_reports_access: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Allow this role to view Usage Report. Currently only 'none' and 'all' values are supported.")]
    usage_reports_access: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateRotatedSecretInput {
    provider_type: Option<String>,
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "API ID to rotate")]
    api_id: Option<String>,
    #[schemars(description = "API key to rotate")]
    api_key: Option<String>,
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation [true/false]")]
    auto_rotate: Option<String>,
    #[schemars(description = "Aws Region (relevant only for aws)")]
    aws_region: Option<String>,
    #[schemars(description = "Secret payload to be sent with rotation request (relevant only for rotator-type=custom)")]
    custom_payload: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Base64-encoded service account private key text")]
    gcp_key: Option<String>,
    #[schemars(description = "Create a new access key without deleting the old key from AWS for backup (relevant only for AWS) [true/false]")]
    grace_rotation: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Secret name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_metadata: Option<String>,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Rotate the value of the secret after SRA session ends [true/false]")]
    rotate_after_disconnect: Option<String>,
    #[schemars(description = "rotated-username password")]
    rotated_password: Option<String>,
    #[schemars(description = "username to be rotated, if selected use-self-creds at rotator-creds-type, this username will try to rotate it's own password, if use-target-creds is selected, target credentials will be use to rotate the rotated-password")]
    rotated_username: Option<String>,
    #[schemars(description = "The Hour of the rotation in UTC")]
    rotation_hour: Option<i64>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (7-365)")]
    rotation_interval: Option<String>,
    #[schemars(description = "The credentials to connect with use-self-creds/use-target-creds")]
    rotator_creds_type: Option<String>,
    #[schemars(description = "\"Custom rotation command (relevant only for ssh target)")]
    rotator_custom_cmd: Option<String>,
    #[schemars(description = "Rotate same password for each host from the Linked Target (relevant only for Linked Target)")]
    same_password: Option<String>,
    #[schemars(description = "Allow providing external user for a domain users (relevant only for rdp)")]
    secure_access_allow_external_user: Option<bool>,
    #[schemars(description = "The AWS account id (relevant only for aws)")]
    secure_access_aws_account_id: Option<String>,
    #[schemars(description = "The AWS native cli")]
    secure_access_aws_native_cli: Option<bool>,
    #[schemars(description = "Deprecated. use secure-access-certificate-issuer")]
    secure_access_bastion_issuer: Option<String>,
    #[schemars(description = "Path to the SSH Certificate Issuer for your Akeyless Secure Access")]
    secure_access_certificate_issuer: Option<String>,
    #[schemars(description = "The DB name (relevant only for DB Dynamic-Secret)")]
    secure_access_db_name: Option<String>,
    #[schemars(description = "The db schema (relevant only for mssql or postgresql)")]
    secure_access_db_schema: Option<String>,
    #[schemars(description = "Enable this flag to prevent simultaneous use of the same secret")]
    secure_access_disable_concurrent_connections: Option<bool>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Required when the Dynamic Secret is used for a domain user (relevant only for RDP Dynamic-Secret)")]
    secure_access_rdp_domain: Option<String>,
    #[schemars(description = "Override the RDP Domain username (relevant only for rdp)")]
    secure_access_rdp_user: Option<String>,
    #[schemars(description = "Destination URL to inject secrets")]
    secure_access_url: Option<String>,
    #[schemars(description = "Enable Web Secure Remote Access")]
    secure_access_web: Option<bool>,
    #[schemars(description = "Secure browser viaAkeyless's Secure Remote Access (SRA) (relevant only for aws or azure)")]
    secure_access_web_browsing: Option<bool>,
    #[schemars(description = "Web-Proxy via Akeyless's Secure Remote Access (SRA) (relevant only for aws or azure)")]
    secure_access_web_proxy: Option<bool>,
    #[schemars(description = "Deprecated: use RotatedPassword")]
    ssh_password: Option<String>,
    #[schemars(description = "Deprecated: use RotatedUser")]
    ssh_username: Option<String>,
    #[schemars(description = "The name of the storage account key to rotate [key1/key2/kerb1/kerb2]")]
    storage_account_key_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "LDAP User Attribute, Default value \"cn\"")]
    user_attribute: Option<String>,
    #[schemars(description = "LDAP User Base DN")]
    user_dn: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateRotationSettingsInput {
    #[schemars(description = "Whether to automatically rotate every --rotation-interval days, or disable existing automatic rotation")]
    auto_rotate: bool,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Key name")]
    name: String,
    #[schemars(description = "How many days before the rotation of the item would you like to be notified")]
    rotation_event_in: Option<Vec<String>>,
    #[schemars(description = "The number of days to wait between every automatic key rotation (7-365)")]
    rotation_interval: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateSalesforceTargetInput {
    #[schemars(description = "Base64 encoded PEM of the connected app private key (relevant for JWT auth only)")]
    app_private_key_data: Option<String>,
    #[schemars(description = "type of the auth flow ('jwt' / 'user-password')")]
    auth_flow: String,
    #[schemars(description = "Base64 encoded PEM cert to use when uploading a new key to Salesforce")]
    ca_cert_data: Option<String>,
    #[schemars(description = "name of the certificate in Salesforce tenant to use when uploading new key")]
    ca_cert_name: Option<String>,
    #[schemars(description = "Client ID of the oauth2 app to use for connecting to Salesforce")]
    client_id: String,
    #[schemars(description = "Client secret of the oauth2 app to use for connecting to Salesforce (required for password flow)")]
    client_secret: Option<String>,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "The email of the user attached to the oauth2 app used for connecting to Salesforce")]
    email: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "The password of the user attached to the oauth2 app used for connecting to Salesforce (required for user-password flow)")]
    password: Option<String>,
    #[schemars(description = "The security token of the user attached to the oauth2 app used for connecting to Salesforce  (required for user-password flow)")]
    security_token: Option<String>,
    #[schemars(description = "Url of the Salesforce tenant")]
    tenant_url: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateSecretValInput {
    #[schemars(description = "for personal password manager")]
    accessibility: Option<String>,
    #[schemars(description = "For Password Management use, additional fields")]
    custom_field: Option<serde_json::Value>,
    #[schemars(description = "Secret format [text/json/key-value] (relevant only for type 'generic')")]
    format: Option<String>,
    #[schemars(description = "For Password Management use, reflect the website context")]
    inject_url: Option<Vec<String>>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "The last version number before the update")]
    last_version: Option<i64>,
    #[schemars(description = "The provided value is a multiline value (separated by '\\n')")]
    multiline: Option<bool>,
    #[schemars(description = "Secret name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "For Password Management use, additional fields")]
    password: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "For Password Management use")]
    username: Option<String>,
    #[schemars(description = "The secret value (relevant only for type 'generic')")]
    value: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateSshCertIssuerInput {
    provider_type: Option<String>,
    #[schemars(description = "List of the new tags that will be attached to this item")]
    add_tag: Option<Vec<String>>,
    #[schemars(description = "Users allowed to fetch the certificate, e.g root,ubuntu")]
    allowed_users: String,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Signed certificates with extensions, e.g permit-port-forwarding=\\\"\\\"")]
    extensions: Option<serde_json::Value>,
    #[schemars(description = "Externally provided username [true/false]")]
    external_username: Option<String>,
    #[schemars(description = "For externally provided users, denotes the key-name of IdP claim to extract the username from (relevant only for external-username=true)")]
    fixed_user_claim_keyname: Option<String>,
    #[schemars(description = "Host provider type [explicit/target], Default Host provider is explicit, Relevant only for Secure Remote Access of ssh cert issuer, ldap rotated secret and ldap dynamic secret")]
    host_provider: Option<String>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "SSH certificate issuer name")]
    name: String,
    #[schemars(description = "New item name")]
    new_name: Option<String>,
    #[schemars(description = "Signed certificates with principal, e.g example_role1,example_role2")]
    principals: Option<String>,
    #[schemars(description = "List of the existent tags that will be removed from this item")]
    rm_tag: Option<Vec<String>>,
    #[schemars(description = "Secure Access SSH control API endpoint. E.g. https://my.sra-server:9900")]
    secure_access_api: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-api")]
    secure_access_bastion_api: Option<String>,
    #[schemars(description = "Deprecated. use secure-access-ssh")]
    secure_access_bastion_ssh: Option<String>,
    #[schemars(description = "Enable/Disable secure remote access [true/false]")]
    secure_access_enable: Option<String>,
    #[schemars(description = "Enable this flag to enforce connections only to the hosts listed in --secure-access-host")]
    secure_access_enforce_hosts_restriction: Option<bool>,
    secure_access_gateway: Option<String>,
    #[schemars(description = "Target servers for connections (In case of Linked Target association, host(s) will inherit Linked Target hosts - Relevant only for Dynamic Secrets/producers)")]
    secure_access_host: Option<Vec<String>>,
    #[schemars(description = "Bastion's SSH server. E.g. my.sra-server:22")]
    secure_access_ssh: Option<String>,
    #[schemars(description = "SSH username to connect to target server, must be in 'Allowed Users' list")]
    secure_access_ssh_creds_user: Option<String>,
    #[schemars(description = "Deprecated. Use secure-access-use-internal-ssh-access")]
    secure_access_use_internal_bastion: Option<bool>,
    #[schemars(description = "Use internal SSH Access")]
    secure_access_use_internal_ssh_access: Option<bool>,
    #[schemars(description = "A key to sign the certificate with")]
    signer_key_name: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The requested Time To Live for the certificate, in seconds")]
    ttl: i64,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateSshTargetInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "SSH host name")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "SSH port")]
    port: Option<String>,
    #[schemars(description = "SSH private key")]
    private_key: Option<String>,
    #[schemars(description = "SSH private key password")]
    private_key_password: Option<String>,
    #[schemars(description = "SSH password to rotate")]
    ssh_password: Option<String>,
    #[schemars(description = "SSH username")]
    ssh_username: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateSshTargetDetailsInput {
    #[schemars(description = "The ssh host name")]
    host: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "ssh port")]
    port: Option<String>,
    #[schemars(description = "ssh private key")]
    private_key: Option<String>,
    #[schemars(description = "The ssh private key password")]
    private_key_password: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "ssh pawssword to rotate")]
    ssh_password: Option<String>,
    #[schemars(description = "ssh username")]
    ssh_username: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateTargetInput {
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated - use description")]
    new_comment: Option<String>,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateTargetDetailsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateWebTargetInput {
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    #[schemars(description = "The url")]
    url: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateWebTargetDetailsInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "Deprecated")]
    new_version: Option<bool>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    protection_key: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    url: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateWindowsTargetInput {
    #[schemars(description = "SSL CA certificate in base64 encoding generated from a trusted Certificate Authority (CA)")]
    certificate: Option<String>,
    #[schemars(description = "Type of connection to Windows Server [credentials/parent-target]")]
    connection_type: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "User domain name")]
    domain: Option<String>,
    #[schemars(description = "Server hostname")]
    hostname: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Name of the parent target, relevant only when connection-type is parent-target")]
    parent_target_name: Option<String>,
    #[schemars(description = "Privileged user password")]
    password: String,
    #[schemars(description = "Server WinRM port")]
    port: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
    #[schemars(description = "Enable/Disable TLS for WinRM over HTTPS [true/false]")]
    use_tls: Option<String>,
    #[schemars(description = "Privileged username")]
    username: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UpdateZeroSslTargetInput {
    #[schemars(description = "API Key of the ZeroSSLTarget account")]
    api_key: String,
    #[schemars(description = "Deprecated - use description")]
    comment: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "ImapFQDN of the IMAP service, FQDN or IPv4 address. Must be FQDN if the IMAP is using TLS")]
    imap_fqdn: String,
    #[schemars(description = "ImapPassword to access the IMAP service")]
    imap_password: String,
    #[schemars(description = "ImapPort of the IMAP service")]
    imap_port: Option<String>,
    #[schemars(description = "ImapValidationEmail to use when asking ZeroSSL to send a validation email, if empty will user imap-username")]
    imap_target_email: Option<String>,
    #[schemars(description = "ImapUsername to access the IMAP service")]
    imap_username: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Whether to keep previous version [true/false]. If not set, use default according to account settings")]
    keep_prev_version: Option<String>,
    #[schemars(description = "The name of a key that used to encrypt the target secret value (if empty, the account default protectionKey key will be used)")]
    key: Option<String>,
    #[schemars(description = "Set the maximum number of versions, limited by the account settings defaults.")]
    max_versions: Option<String>,
    #[schemars(description = "Target name")]
    name: String,
    #[schemars(description = "New target name")]
    new_name: Option<String>,
    #[schemars(description = "Timeout waiting for certificate validation in Duration format (1h - 1 Hour, 20m - 20 Minutes, 33m3s - 33 Minutes and 3 Seconds), maximum 1h.")]
    timeout: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Deprecated")]
    update_version: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UploadRsaInput {
    #[schemars(description = "Key type. options: [RSA1024, RSA2048, RSA3072, RSA4096]")]
    alg: String,
    #[schemars(description = "Certificate in a PEM format.")]
    cert_file_data: Option<String>,
    certificate_format: Option<String>,
    #[schemars(description = "The customer fragment ID that will be used to split the key (if empty, the key will be created independently of a customer fragment)")]
    customer_frg_id: Option<String>,
    #[schemars(description = "Protection from accidental deletion of this object [true/false]")]
    delete_protection: Option<String>,
    #[schemars(description = "Description of the object")]
    description: Option<String>,
    #[schemars(description = "How many days before the expiration of the certificate would you like to be notified.")]
    expiration_event_in: Option<Vec<String>>,
    #[schemars(description = "Additional custom fields to associate with the item")]
    item_custom_fields: Option<serde_json::Value>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Deprecated - use description")]
    metadata: Option<String>,
    #[schemars(description = "Name of key to be created")]
    name: String,
    #[schemars(description = "When the overwrite flag is set, this command will only update an existing key [true/false]")]
    overwrite: Option<String>,
    #[schemars(description = "RSA private key data, base64 encoded")]
    rsa_file_data: Option<String>,
    #[schemars(description = "The number of fragments that the item will be split into")]
    split_level: Option<i64>,
    #[schemars(description = "List of the tags attached to this key")]
    tag: Option<Vec<String>>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UscCreateInput {
    #[schemars(description = "Use this option if the universal secrets value is a base64 encoded binary")]
    binary_value: Option<bool>,
    #[schemars(description = "Description of the universal secrets")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The namespace (relevant for Hashi vault target)")]
    namespace: Option<String>,
    object_type: Option<String>,
    #[schemars(description = "Optional, the passphrase that protects the private key within the pfx certificate (Relevant only for Azure KV certificates)")]
    pfx_password: Option<String>,
    #[schemars(description = "Optional, create secret in a specific region (GCP only). If empty, a global secret will be created (provider default).")]
    region: Option<String>,
    #[schemars(description = "Name for the new universal secrets")]
    secret_name: String,
    #[schemars(description = "Tags for the universal secrets")]
    tags: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Optional, The name of the remote key that used to encrypt the secret value (if empty, the default key will be used)")]
    usc_encryption_key: Option<String>,
    #[schemars(description = "Name of the Universal Secrets Connector item")]
    usc_name: String,
    #[schemars(description = "Value of the universal secrets item, either text or base64 encoded binary")]
    value: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UscDeleteInput {
    #[schemars(description = "Force delete objects that are soft deleted by default (relavent only for Azure target)")]
    force_delete: Option<bool>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The namespace (relevant for Hashi vault target)")]
    namespace: Option<String>,
    #[schemars(description = "The universal secrets id (or name, for AWS, Azure, K8s or Hashi vault targets) to delete")]
    secret_id: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Name of the Universal Secrets Connector item")]
    usc_name: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UscGetInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The namespace (relevant for Hashi vault target)")]
    namespace: Option<String>,
    #[schemars(description = "The secret id (or name, for AWS, Azure, K8s or Hashi vault targets) to get from the Universal Secrets Connector")]
    secret_id: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Name of the Universal Secrets Connector item")]
    usc_name: String,
    #[schemars(description = "The version id (if not specified, will retrieve the last version)")]
    version_id: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UscListInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    object_type: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Name of the Universal Secrets Connector item")]
    usc_name: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct UscUpdateInput {
    #[schemars(description = "Use this option if the universal secrets value is a base64 encoded binary")]
    binary_value: Option<bool>,
    #[schemars(description = "Description of the universal secrets")]
    description: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The namespace (relevant for Hashi vault target)")]
    namespace: Option<String>,
    #[schemars(description = "Optional, the passphrase that protects the private key within the pfx certificate (Relevant only for Azure KV certificates)")]
    pfx_password: Option<String>,
    #[schemars(description = "The universal secrets id (or name, for AWS, Azure, K8s or Hashi vault targets) to update")]
    secret_id: String,
    #[schemars(description = "Tags for the universal secrets")]
    tags: Option<serde_json::Value>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "Optional, The name of the remote key that used to encrypt the secret value (if empty, the default key will be used)")]
    usc_encryption_key: Option<String>,
    #[schemars(description = "Name of the Universal Secrets Connector item")]
    usc_name: String,
    #[schemars(description = "Value of the universal secrets item, either text or base64 encoded binary")]
    value: String,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct GetLastUserEventStatusInput {
    event_source: Option<String>,
    event_type: String,
    #[schemars(description = "Event item name")]
    item_name: String,
    #[schemars(description = "Event item type can be either \"target\" or type of item eg \"static_secret\"/\"dynamic_secret\" To get type of some item run `akeyless describe-item -n {ITEM_NAME} --jq-expression .item_type`")]
    item_type: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The time back to search the event, for example if the value is \"5m\" we will return the last user event issued in the last 5 minutes. By default, we will search without any time boundary.")]
    time_back: Option<String>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ValidateCertificateChallengeInput {
    result: Option<ValidateCertificateChallengeOutput>,
    #[schemars(description = "Certificate display ID from Phase 1")]
    cert_display_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Certificate name (alternative to cert-display-id)")]
    name: Option<String>,
    #[schemars(description = "Validation timeout in seconds")]
    timeout: Option<i64>,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct ValidateTokenInput {
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "Token")]
    token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VaultAddressInput {
    #[schemars(description = "The access-id used to resolve the tenant URLs")]
    access_id: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VerifyDataWithClassicKeyInput {
    #[schemars(description = "Data")]
    data: String,
    #[schemars(description = "The display id of the key to use in the verification process")]
    display_id: Option<String>,
    #[schemars(description = "Defines whether the data should be hashed as part of the signing. If true, the data will not be hashed")]
    hashed: Option<bool>,
    #[schemars(description = "HashingMethod")]
    hashing_method: Option<String>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the verification process")]
    name: String,
    #[schemars(description = "The data's signature in a Base64 format.")]
    signature: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VerifyEcDsaInput {
    #[schemars(description = "The display id of the EC key to use for the verification process")]
    display_id: Option<String>,
    #[schemars(description = "The item id of the EC key to use for the verification process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the EC key to use for the verification process")]
    key_name: Option<String>,
    #[schemars(description = "The message to be verified in a base64 format")]
    message: String,
    #[schemars(description = "Markes that the message is already hashed")]
    prehashed: Option<bool>,
    #[schemars(description = "The message's signature")]
    signature: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The version of the key to use for verification")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VerifyGpgInput {
    #[schemars(description = "The display id of the key to use in the encryption process")]
    display_id: Option<String>,
    #[schemars(description = "The item id of the key to use in the encryption process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the key to use in the encryption process")]
    key_name: String,
    #[schemars(description = "Passphrase that was used to generate the key")]
    passphrase: Option<String>,
    #[schemars(description = "The signature to be verified in base64 format")]
    signature: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VerifyJwtWithClassicKeyInput {
    #[schemars(description = "The name of the key to use in the verify JWT process")]
    display_id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "JWT")]
    jwt: String,
    #[schemars(description = "RequiredClaims")]
    required_claims: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VerifyPkcs1Input {
    #[schemars(description = "The display id of the key to use in the verification process")]
    display_id: Option<String>,
    #[schemars(description = "HashFunction defines the hash function (e.g. sha-256)")]
    hash_function: Option<String>,
    #[schemars(description = "Select default assumed format for the plaintext message. Currently supported options: [base64]")]
    input_format: Option<String>,
    #[schemars(description = "The item id of the key to use in the verification process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the RSA key to use in the verification process")]
    key_name: String,
    #[schemars(description = "The message to be verified")]
    message: String,
    #[schemars(description = "Markes that the message is already hashed")]
    prehashed: Option<bool>,
    #[schemars(description = "The message's signature")]
    signature: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The version of the key to use for verification")]
    version: Option<i64>,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VerifyPkiCertWithClassicKeyInput {
    #[schemars(description = "The name of the key to use in the verify PKICert process")]
    display_id: String,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "PkiCert")]
    pki_cert: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "classic key version")]
    version: i64,
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct VerifyRsaSsaPssInput {
    #[schemars(description = "The display id of the RSA key to use in the verification process")]
    display_id: Option<String>,
    #[schemars(description = "HashFunction defines the hash function (e.g. sha-256)")]
    hash_function: Option<String>,
    #[schemars(description = "The item id of the RSA key to use in the verification process")]
    item_id: Option<i64>,
    #[schemars(description = "Set output format to JSON")]
    json: Option<bool>,
    #[schemars(description = "The name of the RSA key to use in the verification process")]
    key_name: Option<String>,
    #[schemars(description = "The input message to verify in a base64 format")]
    message: String,
    #[schemars(description = "Markes that the message is already hashed")]
    prehashed: Option<bool>,
    #[schemars(description = "The message's signature")]
    signature: String,
    #[schemars(description = "Authentication token (see `/auth` and `/configure`)")]
    token: Option<String>,
    #[schemars(description = "The universal identity token, Required only for universal_identity authentication")]
    uid_token: Option<String>,
    #[schemars(description = "The version of the key to use for verification")]
    version: Option<i64>,
}

// -- MCP Server --

#[derive(Debug, Clone)]
struct AkeylessMcpMcp {
    client: AkeylessMcpClient,
    tool_router: ToolRouter<Self>,
}

#[tool_router]
impl AkeylessMcpMcp {
    fn new() -> Result<Self, String> {
        let config = AkeylessMcpConfig::load();
        let api_key = auth::resolve_api_key(None, &config).map_err(|e| e.to_string())?;
        let client =
            AkeylessMcpClient::new(&config.api_url, &api_key).map_err(|e| e.to_string())?;

        Ok(Self {
            client,
            tool_router: Self::tool_router(),
        })
    }

    #[tool(description = "Create a new custom field.")]
    async fn account_custom_field_create(&self, Parameters(input): Parameters<AccountCustomFieldCreateInput>) -> String {
        let req = crate::api::types::AccountCustomFieldCreate {
            json: input.json.clone(),
            name: input.name.clone(),
            object: input.object.clone(),
            object_type: input.object_type.clone(),
            required: input.required.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.account_custom_field_create(&req).await {
            Ok(result) => format::format_account_custom_field_create(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "Delete a custom field.")]
    async fn account_custom_field_delete(&self, Parameters(input): Parameters<AccountCustomFieldDeleteInput>) -> String {
        let req = crate::api::types::AccountCustomFieldDelete {
            id: input.id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.account_custom_field_delete(&req).await {
            Ok(result) => format::format_account_custom_field_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "Get an account custom field by ID.")]
    async fn account_custom_field_get(&self, Parameters(input): Parameters<AccountCustomFieldGetInput>) -> String {
        let req = crate::api::types::AccountCustomFieldGet {
            id: input.id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.account_custom_field_get(&req).await {
            Ok(result) => format::format_account_custom_field_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "List all account custom fields.")]
    async fn account_custom_field_list(&self, Parameters(input): Parameters<AccountCustomFieldListInput>) -> String {
        let req = crate::api::types::AccountCustomFieldList {
            json: input.json.clone(),
            object: input.object.clone(),
            object_type: input.object_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.account_custom_field_list(&req).await {
            Ok(result) => format::format_account_custom_field_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "Update a custom field.")]
    async fn account_custom_field_update(&self, Parameters(input): Parameters<AccountCustomFieldUpdateInput>) -> String {
        let req = crate::api::types::AccountCustomFieldUpdate {
            id: input.id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            required: input.required.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.account_custom_field_update(&req).await {
            Ok(result) => format::format_account_custom_field_update(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "alias_details operation")]
    async fn alias_details(&self, Parameters(input): Parameters<AliasDetailsInput>) -> String {
        let req = crate::api::types::AliasDetails {
            account_alias: input.account_alias.clone(),
            auth_method_name: input.auth_method_name.clone(),
            json: input.json.clone(),
        };
        match self.client.alias_details(&req).await {
            Ok(result) => format::format_alias_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "assoc_role_auth_method operation")]
    async fn assoc_role_auth_method(&self, Parameters(input): Parameters<AssocRoleAuthMethodInput>) -> String {
        let req = crate::api::types::AssocRoleAuthMethod {
            am_name: input.am_name.clone(),
            case_sensitive: input.case_sensitive.clone(),
            json: input.json.clone(),
            role_name: input.role_name.clone(),
            sub_claims: input.sub_claims.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.assoc_role_auth_method(&req).await {
            Ok(result) => format::format_assoc_role_auth_method(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "assoc_target_item operation")]
    async fn assoc_target_item(&self, Parameters(input): Parameters<AssocTargetItemInput>) -> String {
        let req = crate::api::types::AssocTargetItem {
            certificate_path: input.certificate_path.clone(),
            chain_path: input.chain_path.clone(),
            disable_previous_key_version: input.disable_previous_key_version.clone(),
            external_key_name: input.external_key_name.clone(),
            json: input.json.clone(),
            key_operations: input.key_operations.clone(),
            keyring_name: input.keyring_name.clone(),
            kms_algorithm: input.kms_algorithm.clone(),
            location_id: input.location_id.clone(),
            multi_region: input.multi_region.clone(),
            name: input.name.clone(),
            post_provision_command: input.post_provision_command.clone(),
            private_key_path: input.private_key_path.clone(),
            project_id: input.project_id.clone(),
            protection_level: input.protection_level.clone(),
            purpose: input.purpose.clone(),
            regions: input.regions.clone(),
            sra_association: input.sra_association.clone(),
            target_name: input.target_name.clone(),
            tenant_secret_type: input.tenant_secret_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            vault_name: input.vault_name.clone(),
        };
        match self.client.assoc_target_item(&req).await {
            Ok(result) => format::format_assoc_target_item(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth operation")]
    async fn auth(&self, Parameters(input): Parameters<AuthInput>) -> String {
        let req = crate::api::types::Auth {
            access_id: input.access_id.clone(),
            access_key: input.access_key.clone(),
            access_type: input.access_type.clone(),
            account_id: input.account_id.clone(),
            admin_email: input.admin_email.clone(),
            admin_password: input.admin_password.clone(),
            azure_cloud: input.azure_cloud.clone(),
            cert_challenge: input.cert_challenge.clone(),
            cert_data: input.cert_data.clone(),
            cloud_id: input.cloud_id.clone(),
            debug: input.debug.clone(),
            disable_pafxfast: input.disable_pafxfast.clone(),
            gateway_spn: input.gateway_spn.clone(),
            gateway_url: input.gateway_url.clone(),
            gcp_audience: input.gcp_audience.clone(),
            json: input.json.clone(),
            jwt: input.jwt.clone(),
            k8s_auth_config_name: input.k8s_auth_config_name.clone(),
            k8s_service_account_token: input.k8s_service_account_token.clone(),
            kerberos_token: input.kerberos_token.clone(),
            kerberos_username: input.kerberos_username.clone(),
            key_data: input.key_data.clone(),
            keytab_data: input.keytab_data.clone(),
            krb5_conf_data: input.krb5_conf_data.clone(),
            ldap_password: input.ldap_password.clone(),
            oci_auth_type: input.oci_auth_type.clone(),
            oci_group_ocid: input.oci_group_ocid.clone(),
            otp: input.otp.clone(),
            signed_cert_challenge: input.signed_cert_challenge.clone(),
            uid_token: input.uid_token.clone(),
            use_remote_browser: input.use_remote_browser.clone(),
            username: input.username.clone(),
        };
        match self.client.auth(&req).await {
            Ok(result) => format::format_auth(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_api_key operation")]
    async fn auth_method_create_api_key(&self, Parameters(input): Parameters<AuthMethodCreateApiKeyInput>) -> String {
        let req = crate::api::types::AuthMethodCreateApiKey {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_create_api_key(&req).await {
            Ok(result) => format::format_auth_method_create_api_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_aws_iam operation")]
    async fn auth_method_create_aws_iam(&self, Parameters(input): Parameters<AuthMethodCreateAwsIamInput>) -> String {
        let req = crate::api::types::AuthMethodCreateAwsIam {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_arn: input.bound_arn.clone(),
            bound_aws_account_id: input.bound_aws_account_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_role_id: input.bound_role_id.clone(),
            bound_role_name: input.bound_role_name.clone(),
            bound_user_id: input.bound_user_id.clone(),
            bound_user_name: input.bound_user_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            sts_url: input.sts_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_aws_iam(&req).await {
            Ok(result) => format::format_auth_method_create_aws_iam(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_azure_ad operation")]
    async fn auth_method_create_azure_ad(&self, Parameters(input): Parameters<AuthMethodCreateAzureAdInput>) -> String {
        let req = crate::api::types::AuthMethodCreateAzureAd {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_group_id: input.bound_group_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_providers: input.bound_providers.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_resource_names: input.bound_resource_names.clone(),
            bound_resource_types: input.bound_resource_types.clone(),
            bound_rg_id: input.bound_rg_id.clone(),
            bound_spid: input.bound_spid.clone(),
            bound_sub_id: input.bound_sub_id.clone(),
            bound_tenant_id: input.bound_tenant_id.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_azure_ad(&req).await {
            Ok(result) => format::format_auth_method_create_azure_ad(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_cert operation")]
    async fn auth_method_create_cert(&self, Parameters(input): Parameters<AuthMethodCreateCertInput>) -> String {
        let req = crate::api::types::AuthMethodCreateCert {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_cors: input.allowed_cors.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_common_names: input.bound_common_names.clone(),
            bound_dns_sans: input.bound_dns_sans.clone(),
            bound_email_sans: input.bound_email_sans.clone(),
            bound_extensions: input.bound_extensions.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_organizational_units: input.bound_organizational_units.clone(),
            bound_uri_sans: input.bound_uri_sans.clone(),
            certificate_data: input.certificate_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            require_crl_dp: input.require_crl_dp.clone(),
            revoked_cert_ids: input.revoked_cert_ids.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_cert(&req).await {
            Ok(result) => format::format_auth_method_create_cert(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_email operation")]
    async fn auth_method_create_email(&self, Parameters(input): Parameters<AuthMethodCreateEmailInput>) -> String {
        let req = crate::api::types::AuthMethodCreateEmail {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            email: input.email.clone(),
            enable_mfa: input.enable_mfa.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            mfa_type: input.mfa_type.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_create_email(&req).await {
            Ok(result) => format::format_auth_method_create_email(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_gcp operation")]
    async fn auth_method_create_gcp(&self, Parameters(input): Parameters<AuthMethodCreateGcpInput>) -> String {
        let req = crate::api::types::AuthMethodCreateGcp {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_labels: input.bound_labels.clone(),
            bound_projects: input.bound_projects.clone(),
            bound_regions: input.bound_regions.clone(),
            bound_service_accounts: input.bound_service_accounts.clone(),
            bound_zones: input.bound_zones.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            service_account_creds_data: input.service_account_creds_data.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_gcp(&req).await {
            Ok(result) => format::format_auth_method_create_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_k8s operation")]
    async fn auth_method_create_k8s(&self, Parameters(input): Parameters<AuthMethodCreateK8sInput>) -> String {
        let req = crate::api::types::AuthMethodCreateK8s {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_namespaces: input.bound_namespaces.clone(),
            bound_pod_names: input.bound_pod_names.clone(),
            bound_sa_names: input.bound_sa_names.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            public_key: input.public_key.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_create_k8s(&req).await {
            Ok(result) => format::format_auth_method_create_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_kerberos operation")]
    async fn auth_method_create_kerberos(&self, Parameters(input): Parameters<AuthMethodCreateKerberosInput>) -> String {
        let req = crate::api::types::AuthMethodCreateKerberos {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            group_attr: input.group_attr.clone(),
            group_dn: input.group_dn.clone(),
            group_filter: input.group_filter.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            keytab_file_data: input.keytab_file_data.clone(),
            keytab_file_path: input.keytab_file_path.clone(),
            krb5_conf_data: input.krb5_conf_data.clone(),
            krb5_conf_path: input.krb5_conf_path.clone(),
            ldap_anonymous_search: input.ldap_anonymous_search.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
        };
        match self.client.auth_method_create_kerberos(&req).await {
            Ok(result) => format::format_auth_method_create_kerberos(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_ldap operation")]
    async fn auth_method_create_ldap(&self, Parameters(input): Parameters<AuthMethodCreateLdapInput>) -> String {
        let req = crate::api::types::AuthMethodCreateLdap {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            public_key_data: input.public_key_data.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_ldap(&req).await {
            Ok(result) => format::format_auth_method_create_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_oauth2 operation")]
    async fn auth_method_create_oauth2(&self, Parameters(input): Parameters<AuthMethodCreateOauth2Input>) -> String {
        let req = crate::api::types::AuthMethodCreateOauth2 {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_client_ids: input.bound_client_ids.clone(),
            bound_ips: input.bound_ips.clone(),
            cert: input.cert.clone(),
            cert_file_data: input.cert_file_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gateway_url: input.gateway_url.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_json_data: input.jwks_json_data.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_oauth2(&req).await {
            Ok(result) => format::format_auth_method_create_oauth2(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_oci operation")]
    async fn auth_method_create_oci(&self, Parameters(input): Parameters<AuthMethodCreateOciInput>) -> String {
        let req = crate::api::types::AuthMethodCreateOci {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            group_ocid: input.group_ocid.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            tenant_ocid: input.tenant_ocid.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_create_oci(&req).await {
            Ok(result) => format::format_auth_method_create_oci(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_oidc operation")]
    async fn auth_method_create_oidc(&self, Parameters(input): Parameters<AuthMethodCreateOidcInput>) -> String {
        let req = crate::api::types::AuthMethodCreateOidc {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            required_scopes: input.required_scopes.clone(),
            required_scopes_prefix: input.required_scopes_prefix.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_oidc(&req).await {
            Ok(result) => format::format_auth_method_create_oidc(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_saml operation")]
    async fn auth_method_create_saml(&self, Parameters(input): Parameters<AuthMethodCreateSamlInput>) -> String {
        let req = crate::api::types::AuthMethodCreateSaml {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            idp_metadata_url: input.idp_metadata_url.clone(),
            idp_metadata_xml_data: input.idp_metadata_xml_data.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_create_saml(&req).await {
            Ok(result) => format::format_auth_method_create_saml(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_create_universal_identity operation")]
    async fn auth_method_create_universal_identity(&self, Parameters(input): Parameters<AuthMethodCreateUniversalIdentityInput>) -> String {
        let req = crate::api::types::AuthMethodCreateUniversalIdentity {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            deny_inheritance: input.deny_inheritance.clone(),
            deny_rotate: input.deny_rotate.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_create_universal_identity(&req).await {
            Ok(result) => format::format_auth_method_create_universal_identity(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_delete operation")]
    async fn auth_method_delete(&self, Parameters(input): Parameters<AuthMethodDeleteInput>) -> String {
        let req = crate::api::types::AuthMethodDelete {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_delete(&req).await {
            Ok(result) => format::format_auth_method_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_get operation")]
    async fn auth_method_get(&self, Parameters(input): Parameters<AuthMethodGetInput>) -> String {
        let req = crate::api::types::AuthMethodGet {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_get(&req).await {
            Ok(result) => format::format_auth_method_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_list operation")]
    async fn auth_method_list(&self, Parameters(input): Parameters<AuthMethodListInput>) -> String {
        let req = crate::api::types::AuthMethodList {
            filter: input.filter.clone(),
            json: input.json.clone(),
            pagination_token: input.pagination_token.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_list(&req).await {
            Ok(result) => format::format_auth_method_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_api_key operation")]
    async fn auth_method_update_api_key(&self, Parameters(input): Parameters<AuthMethodUpdateApiKeyInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateApiKey {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_update_api_key(&req).await {
            Ok(result) => format::format_auth_method_update_api_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_aws_iam operation")]
    async fn auth_method_update_aws_iam(&self, Parameters(input): Parameters<AuthMethodUpdateAwsIamInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateAwsIam {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_arn: input.bound_arn.clone(),
            bound_aws_account_id: input.bound_aws_account_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_role_id: input.bound_role_id.clone(),
            bound_role_name: input.bound_role_name.clone(),
            bound_user_id: input.bound_user_id.clone(),
            bound_user_name: input.bound_user_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            sts_url: input.sts_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_aws_iam(&req).await {
            Ok(result) => format::format_auth_method_update_aws_iam(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_azure_ad operation")]
    async fn auth_method_update_azure_ad(&self, Parameters(input): Parameters<AuthMethodUpdateAzureAdInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateAzureAd {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_group_id: input.bound_group_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_providers: input.bound_providers.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_resource_names: input.bound_resource_names.clone(),
            bound_resource_types: input.bound_resource_types.clone(),
            bound_rg_id: input.bound_rg_id.clone(),
            bound_spid: input.bound_spid.clone(),
            bound_sub_id: input.bound_sub_id.clone(),
            bound_tenant_id: input.bound_tenant_id.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_azure_ad(&req).await {
            Ok(result) => format::format_auth_method_update_azure_ad(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_cert operation")]
    async fn auth_method_update_cert(&self, Parameters(input): Parameters<AuthMethodUpdateCertInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateCert {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_cors: input.allowed_cors.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_common_names: input.bound_common_names.clone(),
            bound_dns_sans: input.bound_dns_sans.clone(),
            bound_email_sans: input.bound_email_sans.clone(),
            bound_extensions: input.bound_extensions.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_organizational_units: input.bound_organizational_units.clone(),
            bound_uri_sans: input.bound_uri_sans.clone(),
            certificate_data: input.certificate_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            require_crl_dp: input.require_crl_dp.clone(),
            revoked_cert_ids: input.revoked_cert_ids.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_cert(&req).await {
            Ok(result) => format::format_auth_method_update_cert(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_email operation")]
    async fn auth_method_update_email(&self, Parameters(input): Parameters<AuthMethodUpdateEmailInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateEmail {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_mfa: input.enable_mfa.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            mfa_type: input.mfa_type.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_update_email(&req).await {
            Ok(result) => format::format_auth_method_update_email(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_gcp operation")]
    async fn auth_method_update_gcp(&self, Parameters(input): Parameters<AuthMethodUpdateGcpInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateGcp {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_labels: input.bound_labels.clone(),
            bound_projects: input.bound_projects.clone(),
            bound_regions: input.bound_regions.clone(),
            bound_service_accounts: input.bound_service_accounts.clone(),
            bound_zones: input.bound_zones.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            service_account_creds_data: input.service_account_creds_data.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_gcp(&req).await {
            Ok(result) => format::format_auth_method_update_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_k8s operation")]
    async fn auth_method_update_k8s(&self, Parameters(input): Parameters<AuthMethodUpdateK8sInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateK8s {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_namespaces: input.bound_namespaces.clone(),
            bound_pod_names: input.bound_pod_names.clone(),
            bound_sa_names: input.bound_sa_names.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            public_key: input.public_key.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_update_k8s(&req).await {
            Ok(result) => format::format_auth_method_update_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_kerberos operation")]
    async fn auth_method_update_kerberos(&self, Parameters(input): Parameters<AuthMethodUpdateKerberosInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateKerberos {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            group_attr: input.group_attr.clone(),
            group_dn: input.group_dn.clone(),
            group_filter: input.group_filter.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            keytab_file_data: input.keytab_file_data.clone(),
            keytab_file_path: input.keytab_file_path.clone(),
            krb5_conf_data: input.krb5_conf_data.clone(),
            krb5_conf_path: input.krb5_conf_path.clone(),
            ldap_anonymous_search: input.ldap_anonymous_search.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
        };
        match self.client.auth_method_update_kerberos(&req).await {
            Ok(result) => format::format_auth_method_update_kerberos(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_ldap operation")]
    async fn auth_method_update_ldap(&self, Parameters(input): Parameters<AuthMethodUpdateLdapInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateLdap {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            public_key_data: input.public_key_data.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_ldap(&req).await {
            Ok(result) => format::format_auth_method_update_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_oauth2 operation")]
    async fn auth_method_update_oauth2(&self, Parameters(input): Parameters<AuthMethodUpdateOauth2Input>) -> String {
        let req = crate::api::types::AuthMethodUpdateOauth2 {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_client_ids: input.bound_client_ids.clone(),
            bound_ips: input.bound_ips.clone(),
            cert: input.cert.clone(),
            cert_file_data: input.cert_file_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gateway_url: input.gateway_url.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_json_data: input.jwks_json_data.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_oauth2(&req).await {
            Ok(result) => format::format_auth_method_update_oauth2(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_oci operation")]
    async fn auth_method_update_oci(&self, Parameters(input): Parameters<AuthMethodUpdateOciInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateOci {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            group_ocid: input.group_ocid.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            tenant_ocid: input.tenant_ocid.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_update_oci(&req).await {
            Ok(result) => format::format_auth_method_update_oci(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_oidc operation")]
    async fn auth_method_update_oidc(&self, Parameters(input): Parameters<AuthMethodUpdateOidcInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateOidc {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            required_scopes: input.required_scopes.clone(),
            required_scopes_prefix: input.required_scopes_prefix.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_oidc(&req).await {
            Ok(result) => format::format_auth_method_update_oidc(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_saml operation")]
    async fn auth_method_update_saml(&self, Parameters(input): Parameters<AuthMethodUpdateSamlInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateSaml {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            idp_metadata_url: input.idp_metadata_url.clone(),
            idp_metadata_xml_data: input.idp_metadata_xml_data.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.auth_method_update_saml(&req).await {
            Ok(result) => format::format_auth_method_update_saml(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "auth_method_update_universal_identity operation")]
    async fn auth_method_update_universal_identity(&self, Parameters(input): Parameters<AuthMethodUpdateUniversalIdentityInput>) -> String {
        let req = crate::api::types::AuthMethodUpdateUniversalIdentity {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            deny_inheritance: input.deny_inheritance.clone(),
            deny_rotate: input.deny_rotate.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.auth_method_update_universal_identity(&req).await {
            Ok(result) => format::format_auth_method_update_universal_identity(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "calc_password_security_info operation")]
    async fn calc_password_security_info(&self, Parameters(input): Parameters<CalcPasswordSecurityInfoInput>) -> String {
        let req = crate::api::types::CalcPasswordSecurityInfo {
            json: input.json.clone(),
            min_length: input.min_length.clone(),
            password: input.password.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.calc_password_security_info(&req).await {
            Ok(result) => format::format_calc_password_security_info(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "certificate_discovery operation")]
    async fn certificate_discovery(&self, Parameters(input): Parameters<CertificateDiscoveryInput>) -> String {
        let req = crate::api::types::CertificateDiscovery {
            debug: input.debug.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            hosts: input.hosts.clone(),
            json: input.json.clone(),
            port_ranges: input.port_ranges.clone(),
            protection_key: input.protection_key.clone(),
            target_location: input.target_location.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.certificate_discovery(&req).await {
            Ok(result) => format::format_certificate_discovery(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "change_admin_account_password operation")]
    async fn change_admin_account_password(&self, Parameters(input): Parameters<ChangeAdminAccountPasswordInput>) -> String {
        let req = crate::api::types::ChangeAdminAccountPassword {
            current_password: input.current_password.clone(),
            json: input.json.clone(),
            new_password: input.new_password.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.change_admin_account_password(&req).await {
            Ok(result) => format::format_change_admin_account_password(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "configure operation")]
    async fn configure(&self, Parameters(input): Parameters<ConfigureInput>) -> String {
        let req = crate::api::types::Configure {
            access_id: input.access_id.clone(),
            access_key: input.access_key.clone(),
            access_type: input.access_type.clone(),
            account_id: input.account_id.clone(),
            admin_email: input.admin_email.clone(),
            admin_password: input.admin_password.clone(),
            azure_ad_object_id: input.azure_ad_object_id.clone(),
            azure_cloud: input.azure_cloud.clone(),
            cert_data: input.cert_data.clone(),
            cert_issuer_name: input.cert_issuer_name.clone(),
            cert_username: input.cert_username.clone(),
            default_location_prefix: input.default_location_prefix.clone(),
            disable_pafxfast: input.disable_pafxfast.clone(),
            gateway_spn: input.gateway_spn.clone(),
            gcp_audience: input.gcp_audience.clone(),
            json: input.json.clone(),
            k8s_auth_config_name: input.k8s_auth_config_name.clone(),
            kerberos_token: input.kerberos_token.clone(),
            kerberos_username: input.kerberos_username.clone(),
            key_data: input.key_data.clone(),
            keytab_data: input.keytab_data.clone(),
            krb5_conf_data: input.krb5_conf_data.clone(),
            legacy_signing_alg_name: input.legacy_signing_alg_name.clone(),
            oci_auth_type: input.oci_auth_type.clone(),
            oci_group_ocid: input.oci_group_ocid.clone(),
        };
        match self.client.configure(&req).await {
            Ok(result) => format::format_configure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "connect operation")]
    async fn connect(&self, Parameters(input): Parameters<ConnectInput>) -> String {
        let req = crate::api::types::Connect {
            helper: input.helper.clone(),
            rc_file_override: input.rc_file_override.clone(),
            bastion_ctrl_path: input.bastion_ctrl_path.clone(),
            bastion_ctrl_port: input.bastion_ctrl_port.clone(),
            bastion_ctrl_proto: input.bastion_ctrl_proto.clone(),
            bastion_ctrl_subdomain: input.bastion_ctrl_subdomain.clone(),
            cert_issuer_name: input.cert_issuer_name.clone(),
            gateway_url: input.gateway_url.clone(),
            identity_file: input.identity_file.clone(),
            json: input.json.clone(),
            justification: input.justification.clone(),
            name: input.name.clone(),
            sra_ctrl_path: input.sra_ctrl_path.clone(),
            sra_ctrl_port: input.sra_ctrl_port.clone(),
            sra_ctrl_proto: input.sra_ctrl_proto.clone(),
            sra_ctrl_subdomain: input.sra_ctrl_subdomain.clone(),
            ssh_command: input.ssh_command.clone(),
            ssh_extra_args: input.ssh_extra_args.clone(),
            ssh_legacy_signing_alg: input.ssh_legacy_signing_alg.clone(),
            target: input.target.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_ssh_agent: input.use_ssh_agent.clone(),
            via_bastion: input.via_bastion.clone(),
            via_sra: input.via_sra.clone(),
        };
        match self.client.connect(&req).await {
            Ok(result) => format::format_connect(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_artifactory_target operation")]
    async fn create_artifactory_target(&self, Parameters(input): Parameters<CreateArtifactoryTargetInput>) -> String {
        let req = crate::api::types::CreateArtifactoryTarget {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            base_url: input.base_url.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_artifactory_target(&req).await {
            Ok(result) => format::format_create_artifactory_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method operation")]
    async fn create_auth_method(&self, Parameters(input): Parameters<CreateAuthMethodInput>) -> String {
        let req = crate::api::types::CreateAuthMethod {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_auth_method(&req).await {
            Ok(result) => format::format_create_auth_method(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_awsiam operation")]
    async fn create_auth_method_awsiam(&self, Parameters(input): Parameters<CreateAuthMethodAwsiamInput>) -> String {
        let req = crate::api::types::CreateAuthMethodAwsiam {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_arn: input.bound_arn.clone(),
            bound_aws_account_id: input.bound_aws_account_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_role_id: input.bound_role_id.clone(),
            bound_role_name: input.bound_role_name.clone(),
            bound_user_id: input.bound_user_id.clone(),
            bound_user_name: input.bound_user_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            sts_url: input.sts_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_awsiam(&req).await {
            Ok(result) => format::format_create_auth_method_awsiam(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_azure_ad operation")]
    async fn create_auth_method_azure_ad(&self, Parameters(input): Parameters<CreateAuthMethodAzureAdInput>) -> String {
        let req = crate::api::types::CreateAuthMethodAzureAd {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_group_id: input.bound_group_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_providers: input.bound_providers.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_resource_names: input.bound_resource_names.clone(),
            bound_resource_types: input.bound_resource_types.clone(),
            bound_rg_id: input.bound_rg_id.clone(),
            bound_spid: input.bound_spid.clone(),
            bound_sub_id: input.bound_sub_id.clone(),
            bound_tenant_id: input.bound_tenant_id.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_azure_ad(&req).await {
            Ok(result) => format::format_create_auth_method_azure_ad(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_cert operation")]
    async fn create_auth_method_cert(&self, Parameters(input): Parameters<CreateAuthMethodCertInput>) -> String {
        let req = crate::api::types::CreateAuthMethodCert {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_cors: input.allowed_cors.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_common_names: input.bound_common_names.clone(),
            bound_dns_sans: input.bound_dns_sans.clone(),
            bound_email_sans: input.bound_email_sans.clone(),
            bound_extensions: input.bound_extensions.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_organizational_units: input.bound_organizational_units.clone(),
            bound_uri_sans: input.bound_uri_sans.clone(),
            certificate_data: input.certificate_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            require_crl_dp: input.require_crl_dp.clone(),
            revoked_cert_ids: input.revoked_cert_ids.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_cert(&req).await {
            Ok(result) => format::format_create_auth_method_cert(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_email operation")]
    async fn create_auth_method_email(&self, Parameters(input): Parameters<CreateAuthMethodEmailInput>) -> String {
        let req = crate::api::types::CreateAuthMethodEmail {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            email: input.email.clone(),
            enable_mfa: input.enable_mfa.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            mfa_type: input.mfa_type.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_auth_method_email(&req).await {
            Ok(result) => format::format_create_auth_method_email(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_gcp operation")]
    async fn create_auth_method_gcp(&self, Parameters(input): Parameters<CreateAuthMethodGcpInput>) -> String {
        let req = crate::api::types::CreateAuthMethodGcp {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_labels: input.bound_labels.clone(),
            bound_projects: input.bound_projects.clone(),
            bound_regions: input.bound_regions.clone(),
            bound_service_accounts: input.bound_service_accounts.clone(),
            bound_zones: input.bound_zones.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            service_account_creds_data: input.service_account_creds_data.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_gcp(&req).await {
            Ok(result) => format::format_create_auth_method_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_huawei operation")]
    async fn create_auth_method_huawei(&self, Parameters(input): Parameters<CreateAuthMethodHuaweiInput>) -> String {
        let req = crate::api::types::CreateAuthMethodHuawei {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            auth_url: input.auth_url.clone(),
            bound_domain_id: input.bound_domain_id.clone(),
            bound_domain_name: input.bound_domain_name.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_tenant_id: input.bound_tenant_id.clone(),
            bound_tenant_name: input.bound_tenant_name.clone(),
            bound_user_id: input.bound_user_id.clone(),
            bound_user_name: input.bound_user_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_auth_method_huawei(&req).await {
            Ok(result) => format::format_create_auth_method_huawei(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_k8s operation")]
    async fn create_auth_method_k8s(&self, Parameters(input): Parameters<CreateAuthMethodK8sInput>) -> String {
        let req = crate::api::types::CreateAuthMethodK8s {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_namespaces: input.bound_namespaces.clone(),
            bound_pod_names: input.bound_pod_names.clone(),
            bound_sa_names: input.bound_sa_names.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            public_key: input.public_key.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_auth_method_k8s(&req).await {
            Ok(result) => format::format_create_auth_method_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_ldap operation")]
    async fn create_auth_method_ldap(&self, Parameters(input): Parameters<CreateAuthMethodLdapInput>) -> String {
        let req = crate::api::types::CreateAuthMethodLdap {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            public_key_data: input.public_key_data.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_ldap(&req).await {
            Ok(result) => format::format_create_auth_method_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_o_auth2 operation")]
    async fn create_auth_method_o_auth2(&self, Parameters(input): Parameters<CreateAuthMethodOAuth2Input>) -> String {
        let req = crate::api::types::CreateAuthMethodOAuth2 {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_client_ids: input.bound_client_ids.clone(),
            bound_ips: input.bound_ips.clone(),
            cert: input.cert.clone(),
            cert_file_data: input.cert_file_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gateway_url: input.gateway_url.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_json_data: input.jwks_json_data.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_o_auth2(&req).await {
            Ok(result) => format::format_create_auth_method_o_auth2(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_oci operation")]
    async fn create_auth_method_oci(&self, Parameters(input): Parameters<CreateAuthMethodOciInput>) -> String {
        let req = crate::api::types::CreateAuthMethodOci {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            group_ocid: input.group_ocid.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            tenant_ocid: input.tenant_ocid.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_auth_method_oci(&req).await {
            Ok(result) => format::format_create_auth_method_oci(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_oidc operation")]
    async fn create_auth_method_oidc(&self, Parameters(input): Parameters<CreateAuthMethodOidcInput>) -> String {
        let req = crate::api::types::CreateAuthMethodOidc {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            required_scopes: input.required_scopes.clone(),
            required_scopes_prefix: input.required_scopes_prefix.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_oidc(&req).await {
            Ok(result) => format::format_create_auth_method_oidc(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_saml operation")]
    async fn create_auth_method_saml(&self, Parameters(input): Parameters<CreateAuthMethodSamlInput>) -> String {
        let req = crate::api::types::CreateAuthMethodSaml {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            idp_metadata_url: input.idp_metadata_url.clone(),
            idp_metadata_xml_data: input.idp_metadata_xml_data.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.create_auth_method_saml(&req).await {
            Ok(result) => format::format_create_auth_method_saml(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_auth_method_universal_identity operation")]
    async fn create_auth_method_universal_identity(&self, Parameters(input): Parameters<CreateAuthMethodUniversalIdentityInput>) -> String {
        let req = crate::api::types::CreateAuthMethodUniversalIdentity {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            deny_inheritance: input.deny_inheritance.clone(),
            deny_rotate: input.deny_rotate.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_auth_method_universal_identity(&req).await {
            Ok(result) => format::format_create_auth_method_universal_identity(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_aws_target operation")]
    async fn create_aws_target(&self, Parameters(input): Parameters<CreateAwsTargetInput>) -> String {
        let req = crate::api::types::CreateAwsTarget {
            access_key: input.access_key.clone(),
            access_key_id: input.access_key_id.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            generate_external_id: input.generate_external_id.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            region: input.region.clone(),
            role_arn: input.role_arn.clone(),
            session_token: input.session_token.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.create_aws_target(&req).await {
            Ok(result) => format::format_create_aws_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_azure_target operation")]
    async fn create_azure_target(&self, Parameters(input): Parameters<CreateAzureTargetInput>) -> String {
        let req = crate::api::types::CreateAzureTarget {
            azure_cloud: input.azure_cloud.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            comment: input.comment.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            resource_group_name: input.resource_group_name.clone(),
            resource_name: input.resource_name.clone(),
            subscription_id: input.subscription_id.clone(),
            tenant_id: input.tenant_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.create_azure_target(&req).await {
            Ok(result) => format::format_create_azure_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_certificate operation")]
    async fn create_certificate(&self, Parameters(input): Parameters<CreateCertificateInput>) -> String {
        let req = crate::api::types::CreateCertificate {
            certificate_data: input.certificate_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            format: input.format.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            key_data: input.key_data.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_certificate(&req).await {
            Ok(result) => format::format_create_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_classic_key operation")]
    async fn create_classic_key(&self, Parameters(input): Parameters<CreateClassicKeyInput>) -> String {
        let req = crate::api::types::CreateClassicKey {
            alg: input.alg.clone(),
            auto_rotate: input.auto_rotate.clone(),
            cert_file_data: input.cert_file_data.clone(),
            certificate_common_name: input.certificate_common_name.clone(),
            certificate_country: input.certificate_country.clone(),
            certificate_digest_algo: input.certificate_digest_algo.clone(),
            certificate_format: input.certificate_format.clone(),
            certificate_locality: input.certificate_locality.clone(),
            certificate_organization: input.certificate_organization.clone(),
            certificate_province: input.certificate_province.clone(),
            certificate_ttl: input.certificate_ttl.clone(),
            conf_file_data: input.conf_file_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            generate_self_signed_certificate: input.generate_self_signed_certificate.clone(),
            gpg_alg: input.gpg_alg.clone(),
            hash_algorithm: input.hash_algorithm.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key_data: input.key_data.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            protection_key_name: input.protection_key_name.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_interval: input.rotation_interval.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_classic_key(&req).await {
            Ok(result) => format::format_create_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_db_target operation")]
    async fn create_db_target(&self, Parameters(input): Parameters<CreateDbTargetInput>) -> String {
        let req = crate::api::types::CreateDbTarget {
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            cloud_service_provider: input.cloud_service_provider.clone(),
            cluster_mode: input.cluster_mode.clone(),
            comment: input.comment.clone(),
            connection_type: input.connection_type.clone(),
            db_name: input.db_name.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            db_type: input.db_type.clone(),
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mongodb_atlas: input.mongodb_atlas.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            name: input.name.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_wallet_login_type: input.oracle_wallet_login_type.clone(),
            oracle_wallet_p12_file_data: input.oracle_wallet_p12_file_data.clone(),
            oracle_wallet_sso_file_data: input.oracle_wallet_sso_file_data.clone(),
            parent_target_name: input.parent_target_name.clone(),
            port: input.port.clone(),
            pwd: input.pwd.clone(),
            snowflake_account: input.snowflake_account.clone(),
            snowflake_api_private_key: input.snowflake_api_private_key.clone(),
            snowflake_api_private_key_password: input.snowflake_api_private_key_password.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_name: input.user_name.clone(),
        };
        match self.client.create_db_target(&req).await {
            Ok(result) => format::format_create_db_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_dfc_key operation")]
    async fn create_dfc_key(&self, Parameters(input): Parameters<CreateDfcKeyInput>) -> String {
        let req = crate::api::types::CreateDfcKey {
            alg: input.alg.clone(),
            auto_rotate: input.auto_rotate.clone(),
            certificate_common_name: input.certificate_common_name.clone(),
            certificate_country: input.certificate_country.clone(),
            certificate_digest_algo: input.certificate_digest_algo.clone(),
            certificate_format: input.certificate_format.clone(),
            certificate_locality: input.certificate_locality.clone(),
            certificate_organization: input.certificate_organization.clone(),
            certificate_province: input.certificate_province.clone(),
            certificate_ttl: input.certificate_ttl.clone(),
            conf_file_data: input.conf_file_data.clone(),
            customer_frg_id: input.customer_frg_id.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            generate_self_signed_certificate: input.generate_self_signed_certificate.clone(),
            hash_algorithm: input.hash_algorithm.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_interval: input.rotation_interval.clone(),
            split_level: input.split_level.clone(),
            tag: input.tag.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_dfc_key(&req).await {
            Ok(result) => format::format_create_dfc_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_dockerhub_target operation")]
    async fn create_dockerhub_target(&self, Parameters(input): Parameters<CreateDockerhubTargetInput>) -> String {
        let req = crate::api::types::CreateDockerhubTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_dockerhub_target(&req).await {
            Ok(result) => format::format_create_dockerhub_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_dynamic_secret operation")]
    async fn create_dynamic_secret(&self, Parameters(input): Parameters<CreateDynamicSecretInput>) -> String {
        let req = crate::api::types::CreateDynamicSecret {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_dynamic_secret(&req).await {
            Ok(result) => format::format_create_dynamic_secret(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_eks_target operation")]
    async fn create_eks_target(&self, Parameters(input): Parameters<CreateEksTargetInput>) -> String {
        let req = crate::api::types::CreateEksTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.create_eks_target(&req).await {
            Ok(result) => format::format_create_eks_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_esm operation")]
    async fn create_esm(&self, Parameters(input): Parameters<CreateEsmInput>) -> String {
        let req = crate::api::types::CreateEsm {
            azure_kv_name: input.azure_kv_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            json: input.json.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            name: input.name.clone(),
            tags: input.tags.clone(),
            target_to_associate: input.target_to_associate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_esm(&req).await {
            Ok(result) => format::format_create_esm(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_event_forwarder operation")]
    async fn create_event_forwarder(&self, Parameters(input): Parameters<CreateEventForwarderInput>) -> String {
        let req = crate::api::types::CreateEventForwarder {
            admin_name: input.admin_name.clone(),
            admin_pwd: input.admin_pwd.clone(),
            app_private_key_base64: input.app_private_key_base64.clone(),
            auth_type: input.auth_type.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            email_to: input.email_to.clone(),
            event_source_locations: input.event_source_locations.clone(),
            event_source_type: input.event_source_type.clone(),
            event_types: input.event_types.clone(),
            every: input.every.clone(),
            forwarder_type: input.forwarder_type.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            runner_type: input.runner_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_email: input.user_email.clone(),
        };
        match self.client.create_event_forwarder(&req).await {
            Ok(result) => format::format_create_event_forwarder(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_gcp_target operation")]
    async fn create_gcp_target(&self, Parameters(input): Parameters<CreateGcpTargetInput>) -> String {
        let req = crate::api::types::CreateGcpTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.create_gcp_target(&req).await {
            Ok(result) => format::format_create_gcp_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_github_target operation")]
    async fn create_github_target(&self, Parameters(input): Parameters<CreateGithubTargetInput>) -> String {
        let req = crate::api::types::CreateGithubTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_github_target(&req).await {
            Ok(result) => format::format_create_github_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_gitlab_target operation")]
    async fn create_gitlab_target(&self, Parameters(input): Parameters<CreateGitlabTargetInput>) -> String {
        let req = crate::api::types::CreateGitlabTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            gitlab_access_token: input.gitlab_access_token.clone(),
            gitlab_certificate: input.gitlab_certificate.clone(),
            gitlab_url: input.gitlab_url.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_gitlab_target(&req).await {
            Ok(result) => format::format_create_gitlab_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_gke_target operation")]
    async fn create_gke_target(&self, Parameters(input): Parameters<CreateGkeTargetInput>) -> String {
        let req = crate::api::types::CreateGkeTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.create_gke_target(&req).await {
            Ok(result) => format::format_create_gke_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_global_sign_atlas_target operation")]
    async fn create_global_sign_atlas_target(&self, Parameters(input): Parameters<CreateGlobalSignAtlasTargetInput>) -> String {
        let req = crate::api::types::CreateGlobalSignAtlasTarget {
            api_key: input.api_key.clone(),
            api_secret: input.api_secret.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mtls_cert_data_base64: input.mtls_cert_data_base64.clone(),
            mtls_key_data_base64: input.mtls_key_data_base64.clone(),
            name: input.name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_global_sign_atlas_target(&req).await {
            Ok(result) => format::format_create_global_sign_atlas_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_global_sign_target operation")]
    async fn create_global_sign_target(&self, Parameters(input): Parameters<CreateGlobalSignTargetInput>) -> String {
        let req = crate::api::types::CreateGlobalSignTarget {
            comment: input.comment.clone(),
            contact_email: input.contact_email.clone(),
            contact_first_name: input.contact_first_name.clone(),
            contact_last_name: input.contact_last_name.clone(),
            contact_phone: input.contact_phone.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            profile_id: input.profile_id.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.create_global_sign_target(&req).await {
            Ok(result) => format::format_create_global_sign_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_godaddy_target operation")]
    async fn create_godaddy_target(&self, Parameters(input): Parameters<CreateGodaddyTargetInput>) -> String {
        let req = crate::api::types::CreateGodaddyTarget {
            api_key: input.api_key.clone(),
            customer_id: input.customer_id.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            secret: input.secret.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_godaddy_target(&req).await {
            Ok(result) => format::format_create_godaddy_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_group operation")]
    async fn create_group(&self, Parameters(input): Parameters<CreateGroupInput>) -> String {
        let req = crate::api::types::CreateGroup {
            description: input.description.clone(),
            group_alias: input.group_alias.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_assignment: input.user_assignment.clone(),
        };
        match self.client.create_group(&req).await {
            Ok(result) => format::format_create_group(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_hashi_vault_target operation")]
    async fn create_hashi_vault_target(&self, Parameters(input): Parameters<CreateHashiVaultTargetInput>) -> String {
        let req = crate::api::types::CreateHashiVaultTarget {
            description: input.description.clone(),
            hashi_url: input.hashi_url.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            namespace: input.namespace.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            vault_token: input.vault_token.clone(),
        };
        match self.client.create_hashi_vault_target(&req).await {
            Ok(result) => format::format_create_hashi_vault_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_native_k8s_target operation")]
    async fn create_native_k8s_target(&self, Parameters(input): Parameters<CreateNativeK8sTargetInput>) -> String {
        let req = crate::api::types::CreateNativeK8sTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            k8s_auth_type: input.k8s_auth_type.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
        };
        match self.client.create_native_k8s_target(&req).await {
            Ok(result) => format::format_create_native_k8s_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_key operation")]
    async fn create_key(&self, Parameters(input): Parameters<CreateKeyInput>) -> String {
        let req = crate::api::types::CreateKey {
            alg: input.alg.clone(),
            certificate_common_name: input.certificate_common_name.clone(),
            certificate_country: input.certificate_country.clone(),
            certificate_digest_algo: input.certificate_digest_algo.clone(),
            certificate_locality: input.certificate_locality.clone(),
            certificate_organization: input.certificate_organization.clone(),
            certificate_province: input.certificate_province.clone(),
            certificate_ttl: input.certificate_ttl.clone(),
            conf_file_data: input.conf_file_data.clone(),
            customer_frg_id: input.customer_frg_id.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            generate_self_signed_certificate: input.generate_self_signed_certificate.clone(),
            hash_algorithm: input.hash_algorithm.clone(),
            json: input.json.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            split_level: input.split_level.clone(),
            tag: input.tag.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_key(&req).await {
            Ok(result) => format::format_create_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "createldap_target operation")]
    async fn createldap_target(&self, Parameters(input): Parameters<CreateldapTargetInput>) -> String {
        let req = crate::api::types::CreateLdapTarget {
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            server_type: input.server_type.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.createldap_target(&req).await {
            Ok(result) => format::format_createldap_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_linked_target operation")]
    async fn create_linked_target(&self, Parameters(input): Parameters<CreateLinkedTargetInput>) -> String {
        let req = crate::api::types::CreateLinkedTarget {
            description: input.description.clone(),
            hosts: input.hosts.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_linked_target(&req).await {
            Ok(result) => format::format_create_linked_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_oidc_app operation")]
    async fn create_oidc_app(&self, Parameters(input): Parameters<CreateOidcAppInput>) -> String {
        let req = crate::api::types::CreateOidcApp {
            accessibility: input.accessibility.clone(),
            audience: input.audience.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            permission_assignment: input.permission_assignment.clone(),
            public: input.public.clone(),
            redirect_uris: input.redirect_uris.clone(),
            scopes: input.scopes.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_oidc_app(&req).await {
            Ok(result) => format::format_create_oidc_app(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_passkey operation")]
    async fn create_passkey(&self, Parameters(input): Parameters<CreatePasskeyInput>) -> String {
        let req = crate::api::types::CreatePasskey {
            accessibility: input.accessibility.clone(),
            alg: input.alg.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            origin_url: input.origin_url.clone(),
            protection_key_name: input.protection_key_name.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.create_passkey(&req).await {
            Ok(result) => format::format_create_passkey(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_ping_target operation")]
    async fn create_ping_target(&self, Parameters(input): Parameters<CreatePingTargetInput>) -> String {
        let req = crate::api::types::CreatePingTarget {
            administrative_port: input.administrative_port.clone(),
            authorization_port: input.authorization_port.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            ping_url: input.ping_url.clone(),
            privileged_user: input.privileged_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_ping_target(&req).await {
            Ok(result) => format::format_create_ping_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_pki_cert_issuer operation")]
    async fn create_pki_cert_issuer(&self, Parameters(input): Parameters<CreatePkiCertIssuerInput>) -> String {
        let req = crate::api::types::CreatePkiCertIssuer {
            allow_any_name: input.allow_any_name.clone(),
            allow_copy_ext_from_csr: input.allow_copy_ext_from_csr.clone(),
            allow_subdomains: input.allow_subdomains.clone(),
            allowed_domains: input.allowed_domains.clone(),
            allowed_extra_extensions: input.allowed_extra_extensions.clone(),
            allowed_ip_sans: input.allowed_ip_sans.clone(),
            allowed_uri_sans: input.allowed_uri_sans.clone(),
            auto_renew: input.auto_renew.clone(),
            ca_target: input.ca_target.clone(),
            client_flag: input.client_flag.clone(),
            code_signing_flag: input.code_signing_flag.clone(),
            country: input.country.clone(),
            create_private_crl: input.create_private_crl.clone(),
            create_private_ocsp: input.create_private_ocsp.clone(),
            create_public_crl: input.create_public_crl.clone(),
            create_public_ocsp: input.create_public_ocsp.clone(),
            critical_key_usage: input.critical_key_usage.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            destination_path: input.destination_path.clone(),
            disable_wildcards: input.disable_wildcards.clone(),
            enable_acme: input.enable_acme.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            gw_cluster_url: input.gw_cluster_url.clone(),
            is_ca: input.is_ca.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key_usage: input.key_usage.clone(),
            locality: input.locality.clone(),
            max_path_len: input.max_path_len.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            not_enforce_hostnames: input.not_enforce_hostnames.clone(),
            not_require_cn: input.not_require_cn.clone(),
            ocsp_ttl: input.ocsp_ttl.clone(),
            organizational_units: input.organizational_units.clone(),
            organizations: input.organizations.clone(),
            postal_code: input.postal_code.clone(),
            protect_certificates: input.protect_certificates.clone(),
            province: input.province.clone(),
            scheduled_renew: input.scheduled_renew.clone(),
            server_flag: input.server_flag.clone(),
            signer_key_name: input.signer_key_name.clone(),
            street_address: input.street_address.clone(),
            tag: input.tag.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_pki_cert_issuer(&req).await {
            Ok(result) => format::format_create_pki_cert_issuer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_rabbit_mq_target operation")]
    async fn create_rabbit_mq_target(&self, Parameters(input): Parameters<CreateRabbitMqTargetInput>) -> String {
        let req = crate::api::types::CreateRabbitMqTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            rabbitmq_server_password: input.rabbitmq_server_password.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_server_user: input.rabbitmq_server_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_rabbit_mq_target(&req).await {
            Ok(result) => format::format_create_rabbit_mq_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_role operation")]
    async fn create_role(&self, Parameters(input): Parameters<CreateRoleInput>) -> String {
        let req = crate::api::types::CreateRole {
            analytics_access: input.analytics_access.clone(),
            audit_access: input.audit_access.clone(),
            comment: input.comment.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            event_center_access: input.event_center_access.clone(),
            event_forwarders_access: input.event_forwarders_access.clone(),
            event_forwarders_name: input.event_forwarders_name.clone(),
            gw_analytics_access: input.gw_analytics_access.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            reverse_rbac_access: input.reverse_rbac_access.clone(),
            sra_reports_access: input.sra_reports_access.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usage_reports_access: input.usage_reports_access.clone(),
        };
        match self.client.create_role(&req).await {
            Ok(result) => format::format_create_role(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_rotated_secret operation")]
    async fn create_rotated_secret(&self, Parameters(input): Parameters<CreateRotatedSecretInput>) -> String {
        let req = crate::api::types::CreateRotatedSecret {
            provider_type: input.provider_type.clone(),
            api_id: input.api_id.clone(),
            api_key: input.api_key.clone(),
            application_id: input.application_id.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            aws_region: input.aws_region.clone(),
            custom_payload: input.custom_payload.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_service_account_email: input.gcp_service_account_email.clone(),
            gcp_service_account_key_id: input.gcp_service_account_key_id.clone(),
            grace_rotation: input.grace_rotation.clone(),
            host_provider: input.host_provider.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_creds_type: input.rotator_creds_type.clone(),
            rotator_custom_cmd: input.rotator_custom_cmd.clone(),
            rotator_type: input.rotator_type.clone(),
            same_password: input.same_password.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_disable_concurrent_connections: input.secure_access_disable_concurrent_connections.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            ssh_password: input.ssh_password.clone(),
            ssh_username: input.ssh_username.clone(),
            storage_account_key_name: input.storage_account_key_name.clone(),
            tags: input.tags.clone(),
            target: input.target.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
        };
        match self.client.create_rotated_secret(&req).await {
            Ok(result) => format::format_create_rotated_secret(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_salesforce_target operation")]
    async fn create_salesforce_target(&self, Parameters(input): Parameters<CreateSalesforceTargetInput>) -> String {
        let req = crate::api::types::CreateSalesforceTarget {
            app_private_key_data: input.app_private_key_data.clone(),
            auth_flow: input.auth_flow.clone(),
            ca_cert_data: input.ca_cert_data.clone(),
            ca_cert_name: input.ca_cert_name.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            email: input.email.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            security_token: input.security_token.clone(),
            tenant_url: input.tenant_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_salesforce_target(&req).await {
            Ok(result) => format::format_create_salesforce_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_secret operation")]
    async fn create_secret(&self, Parameters(input): Parameters<CreateSecretInput>) -> String {
        let req = crate::api::types::CreateSecret {
            accessibility: input.accessibility.clone(),
            change_event: input.change_event.clone(),
            custom_field: input.custom_field.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            format: input.format.clone(),
            inject_url: input.inject_url.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            max_versions: input.max_versions.clone(),
            metadata: input.metadata.clone(),
            multiline_value: input.multiline_value.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            protection_key: input.protection_key.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_gateway: input.secure_access_gateway.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_ssh_creds: input.secure_access_ssh_creds.clone(),
            secure_access_ssh_user: input.secure_access_ssh_user.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
            value: input.value.clone(),
        };
        match self.client.create_secret(&req).await {
            Ok(result) => format::format_create_secret(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_ssh_cert_issuer operation")]
    async fn create_ssh_cert_issuer(&self, Parameters(input): Parameters<CreateSshCertIssuerInput>) -> String {
        let req = crate::api::types::CreateSshCertIssuer {
            provider_type: input.provider_type.clone(),
            allowed_users: input.allowed_users.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            extensions: input.extensions.clone(),
            external_username: input.external_username.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            principals: input.principals.clone(),
            secure_access_api: input.secure_access_api.clone(),
            secure_access_bastion_api: input.secure_access_bastion_api.clone(),
            secure_access_bastion_ssh: input.secure_access_bastion_ssh.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_enforce_hosts_restriction: input.secure_access_enforce_hosts_restriction.clone(),
            secure_access_gateway: input.secure_access_gateway.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_ssh: input.secure_access_ssh.clone(),
            secure_access_ssh_creds_user: input.secure_access_ssh_creds_user.clone(),
            secure_access_use_internal_bastion: input.secure_access_use_internal_bastion.clone(),
            secure_access_use_internal_ssh_access: input.secure_access_use_internal_ssh_access.clone(),
            signer_key_name: input.signer_key_name.clone(),
            tag: input.tag.clone(),
            target: input.target.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_ssh_cert_issuer(&req).await {
            Ok(result) => format::format_create_ssh_cert_issuer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_ssh_target operation")]
    async fn create_ssh_target(&self, Parameters(input): Parameters<CreateSshTargetInput>) -> String {
        let req = crate::api::types::CreateSshTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            port: input.port.clone(),
            private_key: input.private_key.clone(),
            private_key_password: input.private_key_password.clone(),
            ssh_password: input.ssh_password.clone(),
            ssh_username: input.ssh_username.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_ssh_target(&req).await {
            Ok(result) => format::format_create_ssh_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_tokenizer operation")]
    async fn create_tokenizer(&self, Parameters(input): Parameters<CreateTokenizerInput>) -> String {
        let req = crate::api::types::CreateTokenizer {
            alphabet: input.alphabet.clone(),
            decoding_template: input.decoding_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            encoding_template: input.encoding_template.clone(),
            encryption_key_name: input.encryption_key_name.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            pattern: input.pattern.clone(),
            tag: input.tag.clone(),
            template_type: input.template_type.clone(),
            token: input.token.clone(),
            tokenizer_type: input.tokenizer_type.clone(),
            tweak_type: input.tweak_type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_tokenizer(&req).await {
            Ok(result) => format::format_create_tokenizer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_usc operation")]
    async fn create_usc(&self, Parameters(input): Parameters<CreateUscInput>) -> String {
        let req = crate::api::types::CreateUsc {
            azure_kv_name: input.azure_kv_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            environment_names: input.environment_names.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            gcp_sm_regions: input.gcp_sm_regions.clone(),
            github_scope: input.github_scope.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            name: input.name.clone(),
            organization_name: input.organization_name.clone(),
            repository_access: input.repository_access.clone(),
            repository_names: input.repository_names.clone(),
            tags: input.tags.clone(),
            target_to_associate: input.target_to_associate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_prefix: input.usc_prefix.clone(),
            use_prefix_as_filter: input.use_prefix_as_filter.clone(),
        };
        match self.client.create_usc(&req).await {
            Ok(result) => format::format_create_usc(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_user_event operation")]
    async fn create_user_event(&self, Parameters(input): Parameters<CreateUserEventInput>) -> String {
        let req = crate::api::types::CreateUserEvent {
            capabilities: input.capabilities.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            event_source: input.event_source.clone(),
            event_type: input.event_type.clone(),
            item_name: input.item_name.clone(),
            item_type: input.item_type.clone(),
            json: input.json.clone(),
            request_access_ttl: input.request_access_ttl.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_user_event(&req).await {
            Ok(result) => format::format_create_user_event(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_web_target operation")]
    async fn create_web_target(&self, Parameters(input): Parameters<CreateWebTargetInput>) -> String {
        let req = crate::api::types::CreateWebTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.create_web_target(&req).await {
            Ok(result) => format::format_create_web_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_windows_target operation")]
    async fn create_windows_target(&self, Parameters(input): Parameters<CreateWindowsTargetInput>) -> String {
        let req = crate::api::types::CreateWindowsTarget {
            certificate: input.certificate.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            domain: input.domain.clone(),
            hostname: input.hostname.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            password: input.password.clone(),
            port: input.port.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_tls: input.use_tls.clone(),
            username: input.username.clone(),
        };
        match self.client.create_windows_target(&req).await {
            Ok(result) => format::format_create_windows_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "create_zero_ssl_target operation")]
    async fn create_zero_ssl_target(&self, Parameters(input): Parameters<CreateZeroSslTargetInput>) -> String {
        let req = crate::api::types::CreateZeroSslTarget {
            api_key: input.api_key.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_target_email: input.imap_target_email.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.create_zero_ssl_target(&req).await {
            Ok(result) => format::format_create_zero_ssl_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "deactivate_acme_account operation")]
    async fn deactivate_acme_account(&self, Parameters(input): Parameters<DeactivateAcmeAccountInput>) -> String {
        let req = crate::api::types::DeactivateAcmeAccount {
            acme_account_id: input.acme_account_id.clone(),
            cert_issuer_name: input.cert_issuer_name.clone(),
            delete_account: input.delete_account.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.deactivate_acme_account(&req).await {
            Ok(result) => format::format_deactivate_acme_account(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "decrypt operation")]
    async fn decrypt(&self, Parameters(input): Parameters<DecryptInput>) -> String {
        let req = crate::api::types::Decrypt {
            ciphertext: input.ciphertext.clone(),
            display_id: input.display_id.clone(),
            encryption_context: input.encryption_context.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            output_format: input.output_format.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.decrypt(&req).await {
            Ok(result) => format::format_decrypt(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "decrypt_batch operation")]
    async fn decrypt_batch(&self, Parameters(_): Parameters<serde_json::Value>) -> String {
        match self.client.decrypt_batch().await {
            Ok(result) => format::format_decrypt_batch(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "decrypt_gpg operation")]
    async fn decrypt_gpg(&self, Parameters(input): Parameters<DecryptGpgInput>) -> String {
        let req = crate::api::types::DecryptGpg {
            ciphertext: input.ciphertext.clone(),
            display_id: input.display_id.clone(),
            input_format: input.input_format.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            output_format: input.output_format.clone(),
            passphrase: input.passphrase.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.decrypt_gpg(&req).await {
            Ok(result) => format::format_decrypt_gpg(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "decrypt_pkcs1 operation")]
    async fn decrypt_pkcs1(&self, Parameters(input): Parameters<DecryptPkcs1Input>) -> String {
        let req = crate::api::types::DecryptPkcs1 {
            ciphertext: input.ciphertext.clone(),
            display_id: input.display_id.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            output_format: input.output_format.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.decrypt_pkcs1(&req).await {
            Ok(result) => format::format_decrypt_pkcs1(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "decrypt_with_classic_key operation")]
    async fn decrypt_with_classic_key(&self, Parameters(input): Parameters<DecryptWithClassicKeyInput>) -> String {
        let req = crate::api::types::DecryptWithClassicKey {
            ciphertext: input.ciphertext.clone(),
            display_id: input.display_id.clone(),
            ignore_cache: input.ignore_cache.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.decrypt_with_classic_key(&req).await {
            Ok(result) => format::format_decrypt_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_role_association operation")]
    async fn delete_role_association(&self, Parameters(input): Parameters<DeleteRoleAssociationInput>) -> String {
        let req = crate::api::types::DeleteRoleAssociation {
            assoc_id: input.assoc_id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_role_association(&req).await {
            Ok(_) => format!("Success: POST /delete-assoc"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_target_association operation")]
    async fn delete_target_association(&self, Parameters(input): Parameters<DeleteTargetAssociationInput>) -> String {
        let req = crate::api::types::DeleteTargetAssociation {
            assoc_id: input.assoc_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_target_association(&req).await {
            Ok(_) => format!("Success: POST /delete-assoc-target-item"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_auth_method operation")]
    async fn delete_auth_method(&self, Parameters(input): Parameters<DeleteAuthMethodInput>) -> String {
        let req = crate::api::types::DeleteAuthMethod {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_auth_method(&req).await {
            Ok(_) => format!("Success: POST /delete-auth-method"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_auth_methods operation")]
    async fn delete_auth_methods(&self, Parameters(input): Parameters<DeleteAuthMethodsInput>) -> String {
        let req = crate::api::types::DeleteAuthMethods {
            json: input.json.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_auth_methods(&req).await {
            Ok(_) => format!("Success: POST /delete-auth-methods"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_event_forwarder operation")]
    async fn delete_event_forwarder(&self, Parameters(input): Parameters<DeleteEventForwarderInput>) -> String {
        let req = crate::api::types::DeleteEventForwarder {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_event_forwarder(&req).await {
            Ok(_) => format!("Success: POST /delete-event-forwarder"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_gw_cluster operation")]
    async fn delete_gw_cluster(&self, Parameters(input): Parameters<DeleteGwClusterInput>) -> String {
        let req = crate::api::types::DeleteGwCluster {
            cluster_name: input.cluster_name.clone(),
            force_deletion: input.force_deletion.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_gw_cluster(&req).await {
            Ok(_) => format!("Success: POST /delete-gateway-cluster"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_group operation")]
    async fn delete_group(&self, Parameters(input): Parameters<DeleteGroupInput>) -> String {
        let req = crate::api::types::DeleteGroup {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_group(&req).await {
            Ok(_) => format!("Success: POST /delete-group"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_item operation")]
    async fn delete_item(&self, Parameters(input): Parameters<DeleteItemInput>) -> String {
        let req = crate::api::types::DeleteItem {
            accessibility: input.accessibility.clone(),
            delete_immediately: input.delete_immediately.clone(),
            delete_in_days: input.delete_in_days.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.delete_item(&req).await {
            Ok(_) => format!("Success: POST /delete-item"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_items operation")]
    async fn delete_items(&self, Parameters(input): Parameters<DeleteItemsInput>) -> String {
        let req = crate::api::types::DeleteItems {
            item: input.item.clone(),
            json: input.json.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_items(&req).await {
            Ok(_) => format!("Success: POST /delete-items"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_role operation")]
    async fn delete_role(&self, Parameters(input): Parameters<DeleteRoleInput>) -> String {
        let req = crate::api::types::DeleteRole {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_role(&req).await {
            Ok(_) => format!("Success: POST /delete-role"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_role_rule operation")]
    async fn delete_role_rule(&self, Parameters(input): Parameters<DeleteRoleRuleInput>) -> String {
        let req = crate::api::types::DeleteRoleRule {
            json: input.json.clone(),
            path: input.path.clone(),
            role_name: input.role_name.clone(),
            rule_type: input.rule_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_role_rule(&req).await {
            Ok(_) => format!("Success: POST /delete-role-rule"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_roles operation")]
    async fn delete_roles(&self, Parameters(input): Parameters<DeleteRolesInput>) -> String {
        let req = crate::api::types::DeleteRoles {
            json: input.json.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_roles(&req).await {
            Ok(_) => format!("Success: POST /delete-roles"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_target operation")]
    async fn delete_target(&self, Parameters(input): Parameters<DeleteTargetInput>) -> String {
        let req = crate::api::types::DeleteTarget {
            force_deletion: input.force_deletion.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            target_version: input.target_version.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_target(&req).await {
            Ok(_) => format!("Success: POST /delete-target"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_targets operation")]
    async fn delete_targets(&self, Parameters(input): Parameters<DeleteTargetsInput>) -> String {
        let req = crate::api::types::DeleteTargets {
            force_deletion: input.force_deletion.clone(),
            json: input.json.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_targets(&req).await {
            Ok(_) => format!("Success: POST /delete-targets"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "derive_key operation")]
    async fn derive_key(&self, Parameters(input): Parameters<DeriveKeyInput>) -> String {
        let req = crate::api::types::DeriveKey {
            accessibility: input.accessibility.clone(),
            alg: input.alg.clone(),
            hash_function: input.hash_function.clone(),
            iter: input.iter.clone(),
            json: input.json.clone(),
            key_len: input.key_len.clone(),
            mem: input.mem.clone(),
            name: input.name.clone(),
            parallelism: input.parallelism.clone(),
            salt: input.salt.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.derive_key(&req).await {
            Ok(result) => format::format_derive_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "describe_item operation")]
    async fn describe_item(&self, Parameters(input): Parameters<DescribeItemInput>) -> String {
        let req = crate::api::types::DescribeItem {
            accessibility: input.accessibility.clone(),
            bastion_details: input.bastion_details.clone(),
            der_certificate_format: input.der_certificate_format.clone(),
            display_id: input.display_id.clone(),
            gateway_details: input.gateway_details.clone(),
            item_custom_fields_details: input.item_custom_fields_details.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            services_details: input.services_details.clone(),
            show_versions: input.show_versions.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.describe_item(&req).await {
            Ok(result) => format::format_describe_item(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "describe_permissions operation")]
    async fn describe_permissions(&self, Parameters(input): Parameters<DescribePermissionsInput>) -> String {
        let req = crate::api::types::DescribePermissions {
            json: input.json.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.describe_permissions(&req).await {
            Ok(result) => format::format_describe_permissions(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "describe_assoc operation")]
    async fn describe_assoc(&self, Parameters(input): Parameters<DescribeAssocInput>) -> String {
        let req = crate::api::types::DescribeAssoc {
            assoc_id: input.assoc_id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.describe_assoc(&req).await {
            Ok(result) => format::format_describe_assoc(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "describe_sub_claims operation")]
    async fn describe_sub_claims(&self, Parameters(input): Parameters<DescribeSubClaimsInput>) -> String {
        let req = crate::api::types::DescribeSubClaims {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.describe_sub_claims(&req).await {
            Ok(result) => format::format_describe_sub_claims(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "detokenize operation")]
    async fn detokenize(&self, Parameters(input): Parameters<DetokenizeInput>) -> String {
        let req = crate::api::types::Detokenize {
            ciphertext: input.ciphertext.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            tokenizer_name: input.tokenizer_name.clone(),
            tweak: input.tweak.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.detokenize(&req).await {
            Ok(result) => format::format_detokenize(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "detokenize_batch operation")]
    async fn detokenize_batch(&self, Parameters(_): Parameters<serde_json::Value>) -> String {
        match self.client.detokenize_batch().await {
            Ok(result) => format::format_detokenize_batch(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_artifactory operation")]
    async fn dynamic_secret_create_artifactory(&self, Parameters(input): Parameters<DynamicSecretCreateArtifactoryInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateArtifactory {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            artifactory_token_audience: input.artifactory_token_audience.clone(),
            artifactory_token_scope: input.artifactory_token_scope.clone(),
            base_url: input.base_url.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_artifactory(&req).await {
            Ok(result) => format::format_dynamic_secret_create_artifactory(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_aws operation")]
    async fn dynamic_secret_create_aws(&self, Parameters(input): Parameters<DynamicSecretCreateAwsInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateAws {
            access_mode: input.access_mode.clone(),
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            aws_access_key_id: input.aws_access_key_id.clone(),
            aws_access_secret_key: input.aws_access_secret_key.clone(),
            aws_external_id: input.aws_external_id.clone(),
            aws_role_arns: input.aws_role_arns.clone(),
            aws_user_console_access: input.aws_user_console_access.clone(),
            aws_user_groups: input.aws_user_groups.clone(),
            aws_user_policies: input.aws_user_policies.clone(),
            aws_user_programmatic_access: input.aws_user_programmatic_access.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            region: input.region.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            session_tags: input.session_tags.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            transitive_tag_keys: input.transitive_tag_keys.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_aws(&req).await {
            Ok(result) => format::format_dynamic_secret_create_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_azure operation")]
    async fn dynamic_secret_create_azure(&self, Parameters(input): Parameters<DynamicSecretCreateAzureInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateAzure {
            app_obj_id: input.app_obj_id.clone(),
            azure_administrative_unit: input.azure_administrative_unit.clone(),
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_group_obj_id: input.user_group_obj_id.clone(),
            user_portal_access: input.user_portal_access.clone(),
            user_principal_name: input.user_principal_name.clone(),
            user_programmatic_access: input.user_programmatic_access.clone(),
            user_role_template_id: input.user_role_template_id.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_azure(&req).await {
            Ok(result) => format::format_dynamic_secret_create_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_cassandra operation")]
    async fn dynamic_secret_create_cassandra(&self, Parameters(input): Parameters<DynamicSecretCreateCassandraInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateCassandra {
            cassandra_creation_statements: input.cassandra_creation_statements.clone(),
            cassandra_hosts: input.cassandra_hosts.clone(),
            cassandra_password: input.cassandra_password.clone(),
            cassandra_port: input.cassandra_port.clone(),
            cassandra_username: input.cassandra_username.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_cassandra(&req).await {
            Ok(result) => format::format_dynamic_secret_create_cassandra(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_custom operation")]
    async fn dynamic_secret_create_custom(&self, Parameters(input): Parameters<DynamicSecretCreateCustomInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateCustom {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            create_sync_url: input.create_sync_url.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            payload: input.payload.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            revoke_sync_url: input.revoke_sync_url.clone(),
            rotate_sync_url: input.rotate_sync_url.clone(),
            tags: input.tags.clone(),
            timeout_sec: input.timeout_sec.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_custom(&req).await {
            Ok(result) => format::format_dynamic_secret_create_custom(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_dockerhub operation")]
    async fn dynamic_secret_create_dockerhub(&self, Parameters(input): Parameters<DynamicSecretCreateDockerhubInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateDockerhub {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_token_scopes: input.dockerhub_token_scopes.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_dockerhub(&req).await {
            Ok(result) => format::format_dynamic_secret_create_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_eks operation")]
    async fn dynamic_secret_create_eks(&self, Parameters(input): Parameters<DynamicSecretCreateEksInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateEks {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_assume_role: input.eks_assume_role.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_eks(&req).await {
            Ok(result) => format::format_dynamic_secret_create_eks(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_gcp operation")]
    async fn dynamic_secret_create_gcp(&self, Parameters(input): Parameters<DynamicSecretCreateGcpInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateGcp {
            access_type: input.access_type.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            gcp_cred_type: input.gcp_cred_type.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_key_algo: input.gcp_key_algo.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            gcp_sa_email: input.gcp_sa_email.clone(),
            gcp_token_scopes: input.gcp_token_scopes.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            role_binding: input.role_binding.clone(),
            role_names: input.role_names.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            service_account_type: input.service_account_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_gcp(&req).await {
            Ok(result) => format::format_dynamic_secret_create_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_github operation")]
    async fn dynamic_secret_create_github(&self, Parameters(input): Parameters<DynamicSecretCreateGithubInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateGithub {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            installation_id: input.installation_id.clone(),
            installation_organization: input.installation_organization.clone(),
            installation_repository: input.installation_repository.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_permissions: input.token_permissions.clone(),
            token_repositories: input.token_repositories.clone(),
            token_ttl: input.token_ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_create_github(&req).await {
            Ok(result) => format::format_dynamic_secret_create_github(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_gitlab operation")]
    async fn dynamic_secret_create_gitlab(&self, Parameters(input): Parameters<DynamicSecretCreateGitlabInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateGitlab {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gitlab_access_token: input.gitlab_access_token.clone(),
            gitlab_access_type: input.gitlab_access_type.clone(),
            gitlab_certificate: input.gitlab_certificate.clone(),
            gitlab_role: input.gitlab_role.clone(),
            gitlab_token_scopes: input.gitlab_token_scopes.clone(),
            gitlab_url: input.gitlab_url.clone(),
            group_name: input.group_name.clone(),
            installation_organization: input.installation_organization.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_create_gitlab(&req).await {
            Ok(result) => format::format_dynamic_secret_create_gitlab(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_gke operation")]
    async fn dynamic_secret_create_gke(&self, Parameters(input): Parameters<DynamicSecretCreateGkeInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateGke {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_gke(&req).await {
            Ok(result) => format::format_dynamic_secret_create_gke(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_google_workspace operation")]
    async fn dynamic_secret_create_google_workspace(&self, Parameters(input): Parameters<DynamicSecretCreateGoogleWorkspaceInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateGoogleWorkspace {
            access_mode: input.access_mode.clone(),
            admin_email: input.admin_email.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            gcp_key: input.gcp_key.clone(),
            group_email: input.group_email.clone(),
            group_role: input.group_role.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            role_name: input.role_name.clone(),
            role_scope: input.role_scope.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_google_workspace(&req).await {
            Ok(result) => format::format_dynamic_secret_create_google_workspace(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_hana_db operation")]
    async fn dynamic_secret_create_hana_db(&self, Parameters(input): Parameters<DynamicSecretCreateHanaDbInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateHanaDb {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            hana_dbname: input.hana_dbname.clone(),
            hanadb_create_statements: input.hanadb_create_statements.clone(),
            hanadb_host: input.hanadb_host.clone(),
            hanadb_password: input.hanadb_password.clone(),
            hanadb_port: input.hanadb_port.clone(),
            hanadb_revocation_statements: input.hanadb_revocation_statements.clone(),
            hanadb_username: input.hanadb_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_hana_db(&req).await {
            Ok(result) => format::format_dynamic_secret_create_hana_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_k8s operation")]
    async fn dynamic_secret_create_k8s(&self, Parameters(input): Parameters<DynamicSecretCreateK8sInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateK8s {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            k8s_allowed_namespaces: input.k8s_allowed_namespaces.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            k8s_predefined_role_name: input.k8s_predefined_role_name.clone(),
            k8s_predefined_role_type: input.k8s_predefined_role_type.clone(),
            k8s_rolebinding_yaml_data: input.k8s_rolebinding_yaml_data.clone(),
            k8s_rolebinding_yaml_def: input.k8s_rolebinding_yaml_def.clone(),
            k8s_service_account: input.k8s_service_account.clone(),
            k8s_service_account_type: input.k8s_service_account_type.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_dashboard_url: input.secure_access_dashboard_url.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_k8s(&req).await {
            Ok(result) => format::format_dynamic_secret_create_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_ldap operation")]
    async fn dynamic_secret_create_ldap(&self, Parameters(input): Parameters<DynamicSecretCreateLdapInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateLdap {
            provider_type: input.provider_type.clone(),
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            external_username: input.external_username.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            group_dn: input.group_dn.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            tags: input.tags.clone(),
            target: input.target.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_ldap(&req).await {
            Ok(result) => format::format_dynamic_secret_create_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_mongo_db operation")]
    async fn dynamic_secret_create_mongo_db(&self, Parameters(input): Parameters<DynamicSecretCreateMongoDbInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateMongoDb {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_custom_data: input.mongodb_custom_data.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_host_port: input.mongodb_host_port.clone(),
            mongodb_name: input.mongodb_name.clone(),
            mongodb_password: input.mongodb_password.clone(),
            mongodb_roles: input.mongodb_roles.clone(),
            mongodb_scopes: input.mongodb_scopes.clone(),
            mongodb_server_uri: input.mongodb_server_uri.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            mongodb_username: input.mongodb_username.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_mongo_db(&req).await {
            Ok(result) => format::format_dynamic_secret_create_mongo_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_ms_sql operation")]
    async fn dynamic_secret_create_ms_sql(&self, Parameters(input): Parameters<DynamicSecretCreateMsSqlInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateMsSql {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mssql_allowed_db_names: input.mssql_allowed_db_names.clone(),
            mssql_create_statements: input.mssql_create_statements.clone(),
            mssql_dbname: input.mssql_dbname.clone(),
            mssql_host: input.mssql_host.clone(),
            mssql_password: input.mssql_password.clone(),
            mssql_port: input.mssql_port.clone(),
            mssql_revocation_statements: input.mssql_revocation_statements.clone(),
            mssql_username: input.mssql_username.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_ms_sql(&req).await {
            Ok(result) => format::format_dynamic_secret_create_ms_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_my_sql operation")]
    async fn dynamic_secret_create_my_sql(&self, Parameters(input): Parameters<DynamicSecretCreateMySqlInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateMySql {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mysql_dbname: input.mysql_dbname.clone(),
            mysql_host: input.mysql_host.clone(),
            mysql_password: input.mysql_password.clone(),
            mysql_port: input.mysql_port.clone(),
            mysql_revocation_statements: input.mysql_revocation_statements.clone(),
            mysql_screation_statements: input.mysql_screation_statements.clone(),
            mysql_username: input.mysql_username.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_my_sql(&req).await {
            Ok(result) => format::format_dynamic_secret_create_my_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_open_ai operation")]
    async fn dynamic_secret_create_open_ai(&self, Parameters(input): Parameters<DynamicSecretCreateOpenAiInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateOpenAi {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            project_id: input.project_id.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_open_ai(&req).await {
            Ok(result) => format::format_dynamic_secret_create_open_ai(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_oracle_db operation")]
    async fn dynamic_secret_create_oracle_db(&self, Parameters(input): Parameters<DynamicSecretCreateOracleDbInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateOracleDb {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            oracle_host: input.oracle_host.clone(),
            oracle_password: input.oracle_password.clone(),
            oracle_port: input.oracle_port.clone(),
            oracle_revocation_statements: input.oracle_revocation_statements.clone(),
            oracle_screation_statements: input.oracle_screation_statements.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_username: input.oracle_username.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_oracle_db(&req).await {
            Ok(result) => format::format_dynamic_secret_create_oracle_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_ping operation")]
    async fn dynamic_secret_create_ping(&self, Parameters(input): Parameters<DynamicSecretCreatePingInput>) -> String {
        let req = crate::api::types::DynamicSecretCreatePing {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            ping_administrative_port: input.ping_administrative_port.clone(),
            ping_atm_id: input.ping_atm_id.clone(),
            ping_authorization_port: input.ping_authorization_port.clone(),
            ping_cert_subject_dn: input.ping_cert_subject_dn.clone(),
            ping_client_authentication_type: input.ping_client_authentication_type.clone(),
            ping_enforce_replay_prevention: input.ping_enforce_replay_prevention.clone(),
            ping_grant_types: input.ping_grant_types.clone(),
            ping_issuer_dn: input.ping_issuer_dn.clone(),
            ping_jwks: input.ping_jwks.clone(),
            ping_jwks_url: input.ping_jwks_url.clone(),
            ping_password: input.ping_password.clone(),
            ping_privileged_user: input.ping_privileged_user.clone(),
            ping_redirect_uris: input.ping_redirect_uris.clone(),
            ping_restricted_scopes: input.ping_restricted_scopes.clone(),
            ping_signing_algo: input.ping_signing_algo.clone(),
            ping_url: input.ping_url.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_ping(&req).await {
            Ok(result) => format::format_dynamic_secret_create_ping(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_postgre_sql operation")]
    async fn dynamic_secret_create_postgre_sql(&self, Parameters(input): Parameters<DynamicSecretCreatePostgreSqlInput>) -> String {
        let req = crate::api::types::DynamicSecretCreatePostgreSql {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            postgresql_db_name: input.postgresql_db_name.clone(),
            postgresql_host: input.postgresql_host.clone(),
            postgresql_password: input.postgresql_password.clone(),
            postgresql_port: input.postgresql_port.clone(),
            postgresql_username: input.postgresql_username.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            revocation_statement: input.revocation_statement.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_postgre_sql(&req).await {
            Ok(result) => format::format_dynamic_secret_create_postgre_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_rabbit_mq operation")]
    async fn dynamic_secret_create_rabbit_mq(&self, Parameters(input): Parameters<DynamicSecretCreateRabbitMqInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateRabbitMq {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rabbitmq_admin_pwd: input.rabbitmq_admin_pwd.clone(),
            rabbitmq_admin_user: input.rabbitmq_admin_user.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_user_conf_permission: input.rabbitmq_user_conf_permission.clone(),
            rabbitmq_user_read_permission: input.rabbitmq_user_read_permission.clone(),
            rabbitmq_user_tags: input.rabbitmq_user_tags.clone(),
            rabbitmq_user_vhost: input.rabbitmq_user_vhost.clone(),
            rabbitmq_user_write_permission: input.rabbitmq_user_write_permission.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_rabbit_mq(&req).await {
            Ok(result) => format::format_dynamic_secret_create_rabbit_mq(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_rdp operation")]
    async fn dynamic_secret_create_rdp(&self, Parameters(input): Parameters<DynamicSecretCreateRdpInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateRdp {
            allow_user_extend_session: input.allow_user_extend_session.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rdp_admin_name: input.rdp_admin_name.clone(),
            rdp_admin_pwd: input.rdp_admin_pwd.clone(),
            rdp_host_name: input.rdp_host_name.clone(),
            rdp_host_port: input.rdp_host_port.clone(),
            rdp_user_groups: input.rdp_user_groups.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warn_user_before_expiration: input.warn_user_before_expiration.clone(),
        };
        match self.client.dynamic_secret_create_rdp(&req).await {
            Ok(result) => format::format_dynamic_secret_create_rdp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_redis operation")]
    async fn dynamic_secret_create_redis(&self, Parameters(input): Parameters<DynamicSecretCreateRedisInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateRedis {
            acl_rules: input.acl_rules.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            host: input.host.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            password_length: input.password_length.clone(),
            port: input.port.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            username: input.username.clone(),
        };
        match self.client.dynamic_secret_create_redis(&req).await {
            Ok(result) => format::format_dynamic_secret_create_redis(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_redshift operation")]
    async fn dynamic_secret_create_redshift(&self, Parameters(input): Parameters<DynamicSecretCreateRedshiftInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateRedshift {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            redshift_db_name: input.redshift_db_name.clone(),
            redshift_host: input.redshift_host.clone(),
            redshift_password: input.redshift_password.clone(),
            redshift_port: input.redshift_port.clone(),
            redshift_username: input.redshift_username.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_create_redshift(&req).await {
            Ok(result) => format::format_dynamic_secret_create_redshift(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_snowflake operation")]
    async fn dynamic_secret_create_snowflake(&self, Parameters(input): Parameters<DynamicSecretCreateSnowflakeInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateSnowflake {
            account: input.account.clone(),
            account_password: input.account_password.clone(),
            account_username: input.account_username.clone(),
            auth_mode: input.auth_mode.clone(),
            custom_username_template: input.custom_username_template.clone(),
            db_name: input.db_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key_algo: input.key_algo.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            private_key: input.private_key.clone(),
            private_key_passphrase: input.private_key_passphrase.clone(),
            role: input.role.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warehouse: input.warehouse.clone(),
        };
        match self.client.dynamic_secret_create_snowflake(&req).await {
            Ok(result) => format::format_dynamic_secret_create_snowflake(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_create_venafi operation")]
    async fn dynamic_secret_create_venafi(&self, Parameters(input): Parameters<DynamicSecretCreateVenafiInput>) -> String {
        let req = crate::api::types::DynamicSecretCreateVenafi {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            allow_subdomains: input.allow_subdomains.clone(),
            allowed_domains: input.allowed_domains.clone(),
            auto_generated_folder: input.auto_generated_folder.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            root_first_in_chain: input.root_first_in_chain.clone(),
            sign_using_akeyless_pki: input.sign_using_akeyless_pki.clone(),
            signer_key_name: input.signer_key_name.clone(),
            store_private_key: input.store_private_key.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            venafi_access_token: input.venafi_access_token.clone(),
            venafi_api_key: input.venafi_api_key.clone(),
            venafi_baseurl: input.venafi_baseurl.clone(),
            venafi_client_id: input.venafi_client_id.clone(),
            venafi_refresh_token: input.venafi_refresh_token.clone(),
            venafi_use_tpp: input.venafi_use_tpp.clone(),
            venafi_zone: input.venafi_zone.clone(),
        };
        match self.client.dynamic_secret_create_venafi(&req).await {
            Ok(result) => format::format_dynamic_secret_create_venafi(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_delete operation")]
    async fn dynamic_secret_delete(&self, Parameters(input): Parameters<DynamicSecretDeleteInput>) -> String {
        let req = crate::api::types::DynamicSecretDelete {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_delete(&req).await {
            Ok(result) => format::format_dynamic_secret_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_get operation")]
    async fn dynamic_secret_get(&self, Parameters(input): Parameters<DynamicSecretGetInput>) -> String {
        let req = crate::api::types::DynamicSecretGet {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_get(&req).await {
            Ok(result) => format::format_dynamic_secret_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_get_value operation")]
    async fn dynamic_secret_get_value(&self, Parameters(input): Parameters<DynamicSecretGetValueInput>) -> String {
        let req = crate::api::types::DynamicSecretGetValue {
            args: input.args.clone(),
            dbname: input.dbname.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            target: input.target.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_get_value(&req).await {
            Ok(result) => format::format_dynamic_secret_get_value(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_list operation")]
    async fn dynamic_secret_list(&self, Parameters(input): Parameters<DynamicSecretListInput>) -> String {
        let req = crate::api::types::DynamicSecretList {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_list(&req).await {
            Ok(result) => format::format_dynamic_secret_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_tmp_creds_get operation")]
    async fn dynamic_secret_tmp_creds_get(&self, Parameters(input): Parameters<DynamicSecretTmpCredsGetInput>) -> String {
        let req = crate::api::types::DynamicSecretTmpCredsGet {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_tmp_creds_get(&req).await {
            Ok(result) => format::format_dynamic_secret_tmp_creds_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_tmp_creds_delete operation")]
    async fn dynamic_secret_tmp_creds_delete(&self, Parameters(input): Parameters<DynamicSecretTmpCredsDeleteInput>) -> String {
        let req = crate::api::types::DynamicSecretTmpCredsDelete {
            host: input.host.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            revoke_all: input.revoke_all.clone(),
            soft_delete: input.soft_delete.clone(),
            tmp_creds_id: input.tmp_creds_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_tmp_creds_delete(&req).await {
            Ok(result) => format::format_dynamic_secret_tmp_creds_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_tmp_creds_update operation")]
    async fn dynamic_secret_tmp_creds_update(&self, Parameters(input): Parameters<DynamicSecretTmpCredsUpdateInput>) -> String {
        let req = crate::api::types::DynamicSecretTmpCredsUpdate {
            host: input.host.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_ttl_min: input.new_ttl_min.clone(),
            tmp_creds_id: input.tmp_creds_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_tmp_creds_update(&req).await {
            Ok(result) => format::format_dynamic_secret_tmp_creds_update(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_artifactory operation")]
    async fn dynamic_secret_update_artifactory(&self, Parameters(input): Parameters<DynamicSecretUpdateArtifactoryInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateArtifactory {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            artifactory_token_audience: input.artifactory_token_audience.clone(),
            artifactory_token_scope: input.artifactory_token_scope.clone(),
            base_url: input.base_url.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_artifactory(&req).await {
            Ok(result) => format::format_dynamic_secret_update_artifactory(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_aws operation")]
    async fn dynamic_secret_update_aws(&self, Parameters(input): Parameters<DynamicSecretUpdateAwsInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateAws {
            access_mode: input.access_mode.clone(),
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            aws_access_key_id: input.aws_access_key_id.clone(),
            aws_access_secret_key: input.aws_access_secret_key.clone(),
            aws_external_id: input.aws_external_id.clone(),
            aws_role_arns: input.aws_role_arns.clone(),
            aws_user_console_access: input.aws_user_console_access.clone(),
            aws_user_groups: input.aws_user_groups.clone(),
            aws_user_policies: input.aws_user_policies.clone(),
            aws_user_programmatic_access: input.aws_user_programmatic_access.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            region: input.region.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            session_tags: input.session_tags.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            transitive_tag_keys: input.transitive_tag_keys.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_aws(&req).await {
            Ok(result) => format::format_dynamic_secret_update_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_azure operation")]
    async fn dynamic_secret_update_azure(&self, Parameters(input): Parameters<DynamicSecretUpdateAzureInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateAzure {
            app_obj_id: input.app_obj_id.clone(),
            azure_administrative_unit: input.azure_administrative_unit.clone(),
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_group_obj_id: input.user_group_obj_id.clone(),
            user_portal_access: input.user_portal_access.clone(),
            user_principal_name: input.user_principal_name.clone(),
            user_programmatic_access: input.user_programmatic_access.clone(),
            user_role_template_id: input.user_role_template_id.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_azure(&req).await {
            Ok(result) => format::format_dynamic_secret_update_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_cassandra operation")]
    async fn dynamic_secret_update_cassandra(&self, Parameters(input): Parameters<DynamicSecretUpdateCassandraInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateCassandra {
            cassandra_creation_statements: input.cassandra_creation_statements.clone(),
            cassandra_hosts: input.cassandra_hosts.clone(),
            cassandra_password: input.cassandra_password.clone(),
            cassandra_port: input.cassandra_port.clone(),
            cassandra_username: input.cassandra_username.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_cassandra(&req).await {
            Ok(result) => format::format_dynamic_secret_update_cassandra(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_custom operation")]
    async fn dynamic_secret_update_custom(&self, Parameters(input): Parameters<DynamicSecretUpdateCustomInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateCustom {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            create_sync_url: input.create_sync_url.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            payload: input.payload.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            revoke_sync_url: input.revoke_sync_url.clone(),
            rotate_sync_url: input.rotate_sync_url.clone(),
            tags: input.tags.clone(),
            timeout_sec: input.timeout_sec.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_custom(&req).await {
            Ok(result) => format::format_dynamic_secret_update_custom(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_dockerhub operation")]
    async fn dynamic_secret_update_dockerhub(&self, Parameters(input): Parameters<DynamicSecretUpdateDockerhubInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateDockerhub {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_token_scopes: input.dockerhub_token_scopes.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_dockerhub(&req).await {
            Ok(result) => format::format_dynamic_secret_update_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_eks operation")]
    async fn dynamic_secret_update_eks(&self, Parameters(input): Parameters<DynamicSecretUpdateEksInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateEks {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_assume_role: input.eks_assume_role.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_eks(&req).await {
            Ok(result) => format::format_dynamic_secret_update_eks(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_gcp operation")]
    async fn dynamic_secret_update_gcp(&self, Parameters(input): Parameters<DynamicSecretUpdateGcpInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateGcp {
            access_type: input.access_type.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            gcp_cred_type: input.gcp_cred_type.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_key_algo: input.gcp_key_algo.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            gcp_sa_email: input.gcp_sa_email.clone(),
            gcp_token_scopes: input.gcp_token_scopes.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            role_binding: input.role_binding.clone(),
            role_names: input.role_names.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            service_account_type: input.service_account_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_gcp(&req).await {
            Ok(result) => format::format_dynamic_secret_update_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_github operation")]
    async fn dynamic_secret_update_github(&self, Parameters(input): Parameters<DynamicSecretUpdateGithubInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateGithub {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            installation_id: input.installation_id.clone(),
            installation_organization: input.installation_organization.clone(),
            installation_repository: input.installation_repository.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_permissions: input.token_permissions.clone(),
            token_repositories: input.token_repositories.clone(),
            token_ttl: input.token_ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_update_github(&req).await {
            Ok(result) => format::format_dynamic_secret_update_github(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_gitlab operation")]
    async fn dynamic_secret_update_gitlab(&self, Parameters(input): Parameters<DynamicSecretUpdateGitlabInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateGitlab {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gitlab_access_token: input.gitlab_access_token.clone(),
            gitlab_access_type: input.gitlab_access_type.clone(),
            gitlab_certificate: input.gitlab_certificate.clone(),
            gitlab_role: input.gitlab_role.clone(),
            gitlab_token_scopes: input.gitlab_token_scopes.clone(),
            gitlab_url: input.gitlab_url.clone(),
            group_name: input.group_name.clone(),
            installation_organization: input.installation_organization.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.dynamic_secret_update_gitlab(&req).await {
            Ok(result) => format::format_dynamic_secret_update_gitlab(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_gke operation")]
    async fn dynamic_secret_update_gke(&self, Parameters(input): Parameters<DynamicSecretUpdateGkeInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateGke {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_gke(&req).await {
            Ok(result) => format::format_dynamic_secret_update_gke(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_google_workspace operation")]
    async fn dynamic_secret_update_google_workspace(&self, Parameters(input): Parameters<DynamicSecretUpdateGoogleWorkspaceInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateGoogleWorkspace {
            access_mode: input.access_mode.clone(),
            admin_email: input.admin_email.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            gcp_key: input.gcp_key.clone(),
            group_email: input.group_email.clone(),
            group_role: input.group_role.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            role_name: input.role_name.clone(),
            role_scope: input.role_scope.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_google_workspace(&req).await {
            Ok(result) => format::format_dynamic_secret_update_google_workspace(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_hana_db operation")]
    async fn dynamic_secret_update_hana_db(&self, Parameters(input): Parameters<DynamicSecretUpdateHanaDbInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateHanaDb {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            hana_dbname: input.hana_dbname.clone(),
            hanadb_create_statements: input.hanadb_create_statements.clone(),
            hanadb_host: input.hanadb_host.clone(),
            hanadb_password: input.hanadb_password.clone(),
            hanadb_port: input.hanadb_port.clone(),
            hanadb_revocation_statements: input.hanadb_revocation_statements.clone(),
            hanadb_username: input.hanadb_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_hana_db(&req).await {
            Ok(result) => format::format_dynamic_secret_update_hana_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_k8s operation")]
    async fn dynamic_secret_update_k8s(&self, Parameters(input): Parameters<DynamicSecretUpdateK8sInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateK8s {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            k8s_allowed_namespaces: input.k8s_allowed_namespaces.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            k8s_predefined_role_name: input.k8s_predefined_role_name.clone(),
            k8s_predefined_role_type: input.k8s_predefined_role_type.clone(),
            k8s_rolebinding_yaml_data: input.k8s_rolebinding_yaml_data.clone(),
            k8s_rolebinding_yaml_def: input.k8s_rolebinding_yaml_def.clone(),
            k8s_service_account: input.k8s_service_account.clone(),
            k8s_service_account_type: input.k8s_service_account_type.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_dashboard_url: input.secure_access_dashboard_url.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_k8s(&req).await {
            Ok(result) => format::format_dynamic_secret_update_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_ldap operation")]
    async fn dynamic_secret_update_ldap(&self, Parameters(input): Parameters<DynamicSecretUpdateLdapInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateLdap {
            provider_type: input.provider_type.clone(),
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            external_username: input.external_username.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            group_dn: input.group_dn.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            tags: input.tags.clone(),
            target: input.target.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_ldap(&req).await {
            Ok(result) => format::format_dynamic_secret_update_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_mongo_db operation")]
    async fn dynamic_secret_update_mongo_db(&self, Parameters(input): Parameters<DynamicSecretUpdateMongoDbInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateMongoDb {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_custom_data: input.mongodb_custom_data.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_host_port: input.mongodb_host_port.clone(),
            mongodb_name: input.mongodb_name.clone(),
            mongodb_password: input.mongodb_password.clone(),
            mongodb_roles: input.mongodb_roles.clone(),
            mongodb_scopes: input.mongodb_scopes.clone(),
            mongodb_server_uri: input.mongodb_server_uri.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            mongodb_username: input.mongodb_username.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_mongo_db(&req).await {
            Ok(result) => format::format_dynamic_secret_update_mongo_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_ms_sql operation")]
    async fn dynamic_secret_update_ms_sql(&self, Parameters(input): Parameters<DynamicSecretUpdateMsSqlInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateMsSql {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mssql_allowed_db_names: input.mssql_allowed_db_names.clone(),
            mssql_create_statements: input.mssql_create_statements.clone(),
            mssql_dbname: input.mssql_dbname.clone(),
            mssql_host: input.mssql_host.clone(),
            mssql_password: input.mssql_password.clone(),
            mssql_port: input.mssql_port.clone(),
            mssql_revocation_statements: input.mssql_revocation_statements.clone(),
            mssql_username: input.mssql_username.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_ms_sql(&req).await {
            Ok(result) => format::format_dynamic_secret_update_ms_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_my_sql operation")]
    async fn dynamic_secret_update_my_sql(&self, Parameters(input): Parameters<DynamicSecretUpdateMySqlInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateMySql {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mysql_dbname: input.mysql_dbname.clone(),
            mysql_host: input.mysql_host.clone(),
            mysql_password: input.mysql_password.clone(),
            mysql_port: input.mysql_port.clone(),
            mysql_revocation_statements: input.mysql_revocation_statements.clone(),
            mysql_screation_statements: input.mysql_screation_statements.clone(),
            mysql_username: input.mysql_username.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_my_sql(&req).await {
            Ok(result) => format::format_dynamic_secret_update_my_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_open_ai operation")]
    async fn dynamic_secret_update_open_ai(&self, Parameters(input): Parameters<DynamicSecretUpdateOpenAiInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateOpenAi {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            project_id: input.project_id.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_open_ai(&req).await {
            Ok(result) => format::format_dynamic_secret_update_open_ai(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_oracle_db operation")]
    async fn dynamic_secret_update_oracle_db(&self, Parameters(input): Parameters<DynamicSecretUpdateOracleDbInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateOracleDb {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            oracle_host: input.oracle_host.clone(),
            oracle_password: input.oracle_password.clone(),
            oracle_port: input.oracle_port.clone(),
            oracle_revocation_statements: input.oracle_revocation_statements.clone(),
            oracle_screation_statements: input.oracle_screation_statements.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_username: input.oracle_username.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_oracle_db(&req).await {
            Ok(result) => format::format_dynamic_secret_update_oracle_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_ping operation")]
    async fn dynamic_secret_update_ping(&self, Parameters(input): Parameters<DynamicSecretUpdatePingInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdatePing {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            ping_administrative_port: input.ping_administrative_port.clone(),
            ping_atm_id: input.ping_atm_id.clone(),
            ping_authorization_port: input.ping_authorization_port.clone(),
            ping_cert_subject_dn: input.ping_cert_subject_dn.clone(),
            ping_client_authentication_type: input.ping_client_authentication_type.clone(),
            ping_enforce_replay_prevention: input.ping_enforce_replay_prevention.clone(),
            ping_grant_types: input.ping_grant_types.clone(),
            ping_issuer_dn: input.ping_issuer_dn.clone(),
            ping_jwks: input.ping_jwks.clone(),
            ping_jwks_url: input.ping_jwks_url.clone(),
            ping_password: input.ping_password.clone(),
            ping_privileged_user: input.ping_privileged_user.clone(),
            ping_redirect_uris: input.ping_redirect_uris.clone(),
            ping_restricted_scopes: input.ping_restricted_scopes.clone(),
            ping_signing_algo: input.ping_signing_algo.clone(),
            ping_url: input.ping_url.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_ping(&req).await {
            Ok(result) => format::format_dynamic_secret_update_ping(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_postgre_sql operation")]
    async fn dynamic_secret_update_postgre_sql(&self, Parameters(input): Parameters<DynamicSecretUpdatePostgreSqlInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdatePostgreSql {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            postgresql_db_name: input.postgresql_db_name.clone(),
            postgresql_host: input.postgresql_host.clone(),
            postgresql_password: input.postgresql_password.clone(),
            postgresql_port: input.postgresql_port.clone(),
            postgresql_username: input.postgresql_username.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            revocation_statement: input.revocation_statement.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_postgre_sql(&req).await {
            Ok(result) => format::format_dynamic_secret_update_postgre_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_rabbit_mq operation")]
    async fn dynamic_secret_update_rabbit_mq(&self, Parameters(input): Parameters<DynamicSecretUpdateRabbitMqInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateRabbitMq {
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rabbitmq_admin_pwd: input.rabbitmq_admin_pwd.clone(),
            rabbitmq_admin_user: input.rabbitmq_admin_user.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_user_conf_permission: input.rabbitmq_user_conf_permission.clone(),
            rabbitmq_user_read_permission: input.rabbitmq_user_read_permission.clone(),
            rabbitmq_user_tags: input.rabbitmq_user_tags.clone(),
            rabbitmq_user_vhost: input.rabbitmq_user_vhost.clone(),
            rabbitmq_user_write_permission: input.rabbitmq_user_write_permission.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_rabbit_mq(&req).await {
            Ok(result) => format::format_dynamic_secret_update_rabbit_mq(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_rdp operation")]
    async fn dynamic_secret_update_rdp(&self, Parameters(input): Parameters<DynamicSecretUpdateRdpInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateRdp {
            allow_user_extend_session: input.allow_user_extend_session.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rdp_admin_name: input.rdp_admin_name.clone(),
            rdp_admin_pwd: input.rdp_admin_pwd.clone(),
            rdp_host_name: input.rdp_host_name.clone(),
            rdp_host_port: input.rdp_host_port.clone(),
            rdp_user_groups: input.rdp_user_groups.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warn_user_before_expiration: input.warn_user_before_expiration.clone(),
        };
        match self.client.dynamic_secret_update_rdp(&req).await {
            Ok(result) => format::format_dynamic_secret_update_rdp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_redis operation")]
    async fn dynamic_secret_update_redis(&self, Parameters(input): Parameters<DynamicSecretUpdateRedisInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateRedis {
            acl_rules: input.acl_rules.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            host: input.host.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            password_length: input.password_length.clone(),
            port: input.port.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            username: input.username.clone(),
        };
        match self.client.dynamic_secret_update_redis(&req).await {
            Ok(result) => format::format_dynamic_secret_update_redis(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_redshift operation")]
    async fn dynamic_secret_update_redshift(&self, Parameters(input): Parameters<DynamicSecretUpdateRedshiftInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateRedshift {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            redshift_db_name: input.redshift_db_name.clone(),
            redshift_host: input.redshift_host.clone(),
            redshift_password: input.redshift_password.clone(),
            redshift_port: input.redshift_port.clone(),
            redshift_username: input.redshift_username.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.dynamic_secret_update_redshift(&req).await {
            Ok(result) => format::format_dynamic_secret_update_redshift(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_snowflake operation")]
    async fn dynamic_secret_update_snowflake(&self, Parameters(input): Parameters<DynamicSecretUpdateSnowflakeInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateSnowflake {
            account: input.account.clone(),
            account_password: input.account_password.clone(),
            account_username: input.account_username.clone(),
            auth_mode: input.auth_mode.clone(),
            custom_username_template: input.custom_username_template.clone(),
            db_name: input.db_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key_algo: input.key_algo.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            private_key: input.private_key.clone(),
            private_key_passphrase: input.private_key_passphrase.clone(),
            role: input.role.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warehouse: input.warehouse.clone(),
        };
        match self.client.dynamic_secret_update_snowflake(&req).await {
            Ok(result) => format::format_dynamic_secret_update_snowflake(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "dynamic_secret_update_venafi operation")]
    async fn dynamic_secret_update_venafi(&self, Parameters(input): Parameters<DynamicSecretUpdateVenafiInput>) -> String {
        let req = crate::api::types::DynamicSecretUpdateVenafi {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            allow_subdomains: input.allow_subdomains.clone(),
            allowed_domains: input.allowed_domains.clone(),
            auto_generated_folder: input.auto_generated_folder.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            root_first_in_chain: input.root_first_in_chain.clone(),
            sign_using_akeyless_pki: input.sign_using_akeyless_pki.clone(),
            signer_key_name: input.signer_key_name.clone(),
            store_private_key: input.store_private_key.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            venafi_access_token: input.venafi_access_token.clone(),
            venafi_api_key: input.venafi_api_key.clone(),
            venafi_baseurl: input.venafi_baseurl.clone(),
            venafi_client_id: input.venafi_client_id.clone(),
            venafi_refresh_token: input.venafi_refresh_token.clone(),
            venafi_use_tpp: input.venafi_use_tpp.clone(),
            venafi_zone: input.venafi_zone.clone(),
        };
        match self.client.dynamic_secret_update_venafi(&req).await {
            Ok(result) => format::format_dynamic_secret_update_venafi(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "encrypt operation")]
    async fn encrypt(&self, Parameters(input): Parameters<EncryptInput>) -> String {
        let req = crate::api::types::Encrypt {
            display_id: input.display_id.clone(),
            encryption_context: input.encryption_context.clone(),
            input_format: input.input_format.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            plaintext: input.plaintext.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.encrypt(&req).await {
            Ok(result) => format::format_encrypt(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "encrypt_batch operation")]
    async fn encrypt_batch(&self, Parameters(_): Parameters<serde_json::Value>) -> String {
        match self.client.encrypt_batch().await {
            Ok(result) => format::format_encrypt_batch(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "encrypt_gpg operation")]
    async fn encrypt_gpg(&self, Parameters(input): Parameters<EncryptGpgInput>) -> String {
        let req = crate::api::types::EncryptGpg {
            display_id: input.display_id.clone(),
            input_format: input.input_format.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            plaintext: input.plaintext.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.encrypt_gpg(&req).await {
            Ok(result) => format::format_encrypt_gpg(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "encrypt_with_classic_key operation")]
    async fn encrypt_with_classic_key(&self, Parameters(input): Parameters<EncryptWithClassicKeyInput>) -> String {
        let req = crate::api::types::EncryptWithClassicKey {
            display_id: input.display_id.clone(),
            ignore_cache: input.ignore_cache.clone(),
            json: input.json.clone(),
            plaintext: input.plaintext.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.encrypt_with_classic_key(&req).await {
            Ok(result) => format::format_encrypt_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "esm_create operation")]
    async fn esm_create(&self, Parameters(input): Parameters<EsmCreateInput>) -> String {
        let req = crate::api::types::EsmCreate {
            binary_value: input.binary_value.clone(),
            description: input.description.clone(),
            esm_name: input.esm_name.clone(),
            json: input.json.clone(),
            secret_name: input.secret_name.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            value: input.value.clone(),
        };
        match self.client.esm_create(&req).await {
            Ok(result) => format::format_esm_create(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "esm_delete operation")]
    async fn esm_delete(&self, Parameters(input): Parameters<EsmDeleteInput>) -> String {
        let req = crate::api::types::EsmDelete {
            esm_name: input.esm_name.clone(),
            json: input.json.clone(),
            secret_id: input.secret_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.esm_delete(&req).await {
            Ok(result) => format::format_esm_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "esm_get operation")]
    async fn esm_get(&self, Parameters(input): Parameters<EsmGetInput>) -> String {
        let req = crate::api::types::EsmGet {
            esm_name: input.esm_name.clone(),
            json: input.json.clone(),
            secret_id: input.secret_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.esm_get(&req).await {
            Ok(result) => format::format_esm_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "esm_list operation")]
    async fn esm_list(&self, Parameters(input): Parameters<EsmListInput>) -> String {
        let req = crate::api::types::EsmList {
            esm_name: input.esm_name.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.esm_list(&req).await {
            Ok(result) => format::format_esm_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "esm_update operation")]
    async fn esm_update(&self, Parameters(input): Parameters<EsmUpdateInput>) -> String {
        let req = crate::api::types::EsmUpdate {
            binary_value: input.binary_value.clone(),
            description: input.description.clone(),
            esm_name: input.esm_name.clone(),
            json: input.json.clone(),
            secret_id: input.secret_id.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            value: input.value.clone(),
        };
        match self.client.esm_update(&req).await {
            Ok(result) => format::format_esm_update(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_action operation")]
    async fn event_action(&self, Parameters(input): Parameters<EventActionInput>) -> String {
        let req = crate::api::types::EventAction {
            action: input.action.clone(),
            event_id: input.event_id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.event_action(&req).await {
            Ok(result) => format::format_event_action(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_create_email operation")]
    async fn event_forwarder_create_email(&self, Parameters(input): Parameters<EventForwarderCreateEmailInput>) -> String {
        let req = crate::api::types::EventForwarderCreateEmail {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            description: input.description.clone(),
            email_to: input.email_to.clone(),
            event_types: input.event_types.clone(),
            every: input.every.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            include_error: input.include_error.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            override_url: input.override_url.clone(),
            runner_type: input.runner_type.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.event_forwarder_create_email(&req).await {
            Ok(result) => format::format_event_forwarder_create_email(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_create_service_now operation")]
    async fn event_forwarder_create_service_now(&self, Parameters(input): Parameters<EventForwarderCreateServiceNowInput>) -> String {
        let req = crate::api::types::EventForwarderCreateServiceNow {
            admin_name: input.admin_name.clone(),
            admin_pwd: input.admin_pwd.clone(),
            app_private_key_base64: input.app_private_key_base64.clone(),
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            auth_type: input.auth_type.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            description: input.description.clone(),
            event_types: input.event_types.clone(),
            every: input.every.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            host: input.host.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            runner_type: input.runner_type.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_email: input.user_email.clone(),
        };
        match self.client.event_forwarder_create_service_now(&req).await {
            Ok(result) => format::format_event_forwarder_create_service_now(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_create_slack operation")]
    async fn event_forwarder_create_slack(&self, Parameters(input): Parameters<EventForwarderCreateSlackInput>) -> String {
        let req = crate::api::types::EventForwarderCreateSlack {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            description: input.description.clone(),
            event_types: input.event_types.clone(),
            every: input.every.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            runner_type: input.runner_type.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.event_forwarder_create_slack(&req).await {
            Ok(result) => format::format_event_forwarder_create_slack(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_create_teams operation")]
    async fn event_forwarder_create_teams(&self, Parameters(input): Parameters<EventForwarderCreateTeamsInput>) -> String {
        let req = crate::api::types::EventForwarderCreateTeams {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            description: input.description.clone(),
            event_types: input.event_types.clone(),
            every: input.every.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            runner_type: input.runner_type.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.event_forwarder_create_teams(&req).await {
            Ok(result) => format::format_event_forwarder_create_teams(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_create_webhook operation")]
    async fn event_forwarder_create_webhook(&self, Parameters(input): Parameters<EventForwarderCreateWebhookInput>) -> String {
        let req = crate::api::types::EventForwarderCreateWebhook {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            auth_token: input.auth_token.clone(),
            auth_type: input.auth_type.clone(),
            client_cert_data: input.client_cert_data.clone(),
            description: input.description.clone(),
            event_types: input.event_types.clone(),
            every: input.every.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            private_key_data: input.private_key_data.clone(),
            runner_type: input.runner_type.clone(),
            server_certificates: input.server_certificates.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
            username: input.username.clone(),
        };
        match self.client.event_forwarder_create_webhook(&req).await {
            Ok(result) => format::format_event_forwarder_create_webhook(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_delete operation")]
    async fn event_forwarder_delete(&self, Parameters(input): Parameters<EventForwarderDeleteInput>) -> String {
        let req = crate::api::types::EventForwarderDelete {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.event_forwarder_delete(&req).await {
            Ok(result) => format::format_event_forwarder_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_get operation")]
    async fn event_forwarder_get(&self, Parameters(input): Parameters<EventForwarderGetInput>) -> String {
        let req = crate::api::types::EventForwarderGet {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.event_forwarder_get(&req).await {
            Ok(result) => format::format_event_forwarder_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_update_email operation")]
    async fn event_forwarder_update_email(&self, Parameters(input): Parameters<EventForwarderUpdateEmailInput>) -> String {
        let req = crate::api::types::EventForwarderUpdateEmail {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            description: input.description.clone(),
            email_to: input.email_to.clone(),
            enable: input.enable.clone(),
            event_types: input.event_types.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            include_error: input.include_error.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            override_url: input.override_url.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.event_forwarder_update_email(&req).await {
            Ok(result) => format::format_event_forwarder_update_email(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_update_service_now operation")]
    async fn event_forwarder_update_service_now(&self, Parameters(input): Parameters<EventForwarderUpdateServiceNowInput>) -> String {
        let req = crate::api::types::EventForwarderUpdateServiceNow {
            admin_name: input.admin_name.clone(),
            admin_pwd: input.admin_pwd.clone(),
            app_private_key_base64: input.app_private_key_base64.clone(),
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            auth_type: input.auth_type.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            description: input.description.clone(),
            enable: input.enable.clone(),
            event_types: input.event_types.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            host: input.host.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_email: input.user_email.clone(),
        };
        match self.client.event_forwarder_update_service_now(&req).await {
            Ok(result) => format::format_event_forwarder_update_service_now(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_update_slack operation")]
    async fn event_forwarder_update_slack(&self, Parameters(input): Parameters<EventForwarderUpdateSlackInput>) -> String {
        let req = crate::api::types::EventForwarderUpdateSlack {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            description: input.description.clone(),
            enable: input.enable.clone(),
            event_types: input.event_types.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.event_forwarder_update_slack(&req).await {
            Ok(result) => format::format_event_forwarder_update_slack(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_update_teams operation")]
    async fn event_forwarder_update_teams(&self, Parameters(input): Parameters<EventForwarderUpdateTeamsInput>) -> String {
        let req = crate::api::types::EventForwarderUpdateTeams {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            description: input.description.clone(),
            enable: input.enable.clone(),
            event_types: input.event_types.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.event_forwarder_update_teams(&req).await {
            Ok(result) => format::format_event_forwarder_update_teams(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "event_forwarder_update_webhook operation")]
    async fn event_forwarder_update_webhook(&self, Parameters(input): Parameters<EventForwarderUpdateWebhookInput>) -> String {
        let req = crate::api::types::EventForwarderUpdateWebhook {
            auth_methods_event_source_locations: input.auth_methods_event_source_locations.clone(),
            auth_token: input.auth_token.clone(),
            auth_type: input.auth_type.clone(),
            client_cert_data: input.client_cert_data.clone(),
            description: input.description.clone(),
            enable: input.enable.clone(),
            event_types: input.event_types.clone(),
            gateways_event_source_locations: input.gateways_event_source_locations.clone(),
            items_event_source_locations: input.items_event_source_locations.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            private_key_data: input.private_key_data.clone(),
            server_certificates: input.server_certificates.clone(),
            targets_event_source_locations: input.targets_event_source_locations.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
            username: input.username.clone(),
        };
        match self.client.event_forwarder_update_webhook(&req).await {
            Ok(result) => format::format_event_forwarder_update_webhook(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "export_classic_key operation")]
    async fn export_classic_key(&self, Parameters(input): Parameters<ExportClassicKeyInput>) -> String {
        let req = crate::api::types::ExportClassicKey {
            accessibility: input.accessibility.clone(),
            export_public_key: input.export_public_key.clone(),
            ignore_cache: input.ignore_cache.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
            wrapping_key_name: input.wrapping_key_name.clone(),
        };
        match self.client.export_classic_key(&req).await {
            Ok(result) => format::format_export_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "folder_create operation")]
    async fn folder_create(&self, Parameters(input): Parameters<FolderCreateInput>) -> String {
        let req = crate::api::types::FolderCreate {
            accessibility: input.accessibility.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.folder_create(&req).await {
            Ok(result) => format::format_folder_create(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "folder_delete operation")]
    async fn folder_delete(&self, Parameters(input): Parameters<FolderDeleteInput>) -> String {
        let req = crate::api::types::FolderDelete {
            accessibility: input.accessibility.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.folder_delete(&req).await {
            Ok(result) => format::format_folder_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "folder_get operation")]
    async fn folder_get(&self, Parameters(input): Parameters<FolderGetInput>) -> String {
        let req = crate::api::types::FolderGet {
            accessibility: input.accessibility.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.folder_get(&req).await {
            Ok(result) => format::format_folder_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "folder_update operation")]
    async fn folder_update(&self, Parameters(input): Parameters<FolderUpdateInput>) -> String {
        let req = crate::api::types::FolderUpdate {
            accessibility: input.accessibility.clone(),
            add_tag: input.add_tag.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            rm_tag: input.rm_tag.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.folder_update(&req).await {
            Ok(result) => format::format_folder_update(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_allowed_access operation")]
    async fn gateway_create_allowed_access(&self, Parameters(input): Parameters<GatewayCreateAllowedAccessInput>) -> String {
        let req = crate::api::types::GatewayCreateAllowedAccess {
            sub_claims_case_insensitive: input.sub_claims_case_insensitive.clone(),
            access_id: input.access_id.clone(),
            case_sensitive: input.case_sensitive.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            permissions: input.permissions.clone(),
            sub_claims: input.sub_claims.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_create_allowed_access(&req).await {
            Ok(result) => format::format_gateway_create_allowed_access(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_k8s_auth_config operation")]
    async fn gateway_create_k8s_auth_config(&self, Parameters(input): Parameters<GatewayCreateK8sAuthConfigInput>) -> String {
        let req = crate::api::types::GatewayCreateK8sAuthConfig {
            access_id: input.access_id.clone(),
            cluster_api_type: input.cluster_api_type.clone(),
            disable_issuer_validation: input.disable_issuer_validation.clone(),
            json: input.json.clone(),
            k8s_auth_type: input.k8s_auth_type.clone(),
            k8s_ca_cert: input.k8s_ca_cert.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_host: input.k8s_host.clone(),
            k8s_issuer: input.k8s_issuer.clone(),
            name: input.name.clone(),
            rancher_api_key: input.rancher_api_key.clone(),
            rancher_cluster_id: input.rancher_cluster_id.clone(),
            signing_key: input.signing_key.clone(),
            token: input.token.clone(),
            token_exp: input.token_exp.clone(),
            token_reviewer_jwt: input.token_reviewer_jwt.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
        };
        match self.client.gateway_create_k8s_auth_config(&req).await {
            Ok(result) => format::format_gateway_create_k8s_auth_config(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_migration operation")]
    async fn gateway_create_migration(&self, Parameters(input): Parameters<GatewayCreateMigrationInput>) -> String {
        let req = crate::api::types::GatewayCreateMigration {
            service_account_key_decoded: input.service_account_key_decoded.clone(),
            ad_auto_rotate: input.ad_auto_rotate.clone(),
            ad_cert_expiration_event_in: input.ad_cert_expiration_event_in.clone(),
            ad_certificates_path_template: input.ad_certificates_path_template.clone(),
            ad_computer_base_dn: input.ad_computer_base_dn.clone(),
            ad_discover_iis_app: input.ad_discover_iis_app.clone(),
            ad_discover_services: input.ad_discover_services.clone(),
            ad_discovery_types: input.ad_discovery_types.clone(),
            ad_domain_name: input.ad_domain_name.clone(),
            ad_domain_users_path_template: input.ad_domain_users_path_template.clone(),
            ad_local_users_ignore: input.ad_local_users_ignore.clone(),
            ad_local_users_path_template: input.ad_local_users_path_template.clone(),
            ad_os_filter: input.ad_os_filter.clone(),
            ad_rotation_hour: input.ad_rotation_hour.clone(),
            ad_rotation_interval: input.ad_rotation_interval.clone(),
            ad_sra_enable_rdp: input.ad_sra_enable_rdp.clone(),
            ad_ssh_port: input.ad_ssh_port.clone(),
            ad_target_format: input.ad_target_format.clone(),
            ad_target_name: input.ad_target_name.clone(),
            ad_targets_path_template: input.ad_targets_path_template.clone(),
            ad_targets_type: input.ad_targets_type.clone(),
            ad_user_base_dn: input.ad_user_base_dn.clone(),
            ad_user_groups: input.ad_user_groups.clone(),
            ad_winrm_over_http: input.ad_winrm_over_http.clone(),
            ad_winrm_port: input.ad_winrm_port.clone(),
            ad_discover_local_users: input.ad_discover_local_users.clone(),
            ai_certificate_discovery: input.ai_certificate_discovery.clone(),
            aws_key: input.aws_key.clone(),
            aws_key_id: input.aws_key_id.clone(),
            aws_region: input.aws_region.clone(),
            azure_client_id: input.azure_client_id.clone(),
            azure_kv_name: input.azure_kv_name.clone(),
            azure_secret: input.azure_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            conjur_account: input.conjur_account.clone(),
            conjur_api_key: input.conjur_api_key.clone(),
            conjur_url: input.conjur_url.clone(),
            conjur_username: input.conjur_username.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            hashi_json: input.hashi_json.clone(),
            hashi_ns: input.hashi_ns.clone(),
            hashi_token: input.hashi_token.clone(),
            hashi_url: input.hashi_url.clone(),
            hosts: input.hosts.clone(),
            json: input.json.clone(),
            k8s_ca_certificate: input.k8s_ca_certificate.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            k8s_password: input.k8s_password.clone(),
            k8s_skip_system: input.k8s_skip_system.clone(),
            k8s_token: input.k8s_token.clone(),
            k8s_url: input.k8s_url.clone(),
            k8s_username: input.k8s_username.clone(),
            name: input.name.clone(),
            port_ranges: input.port_ranges.clone(),
            protection_key: input.protection_key.clone(),
            si_auto_rotate: input.si_auto_rotate.clone(),
            si_rotation_hour: input.si_rotation_hour.clone(),
            si_rotation_interval: input.si_rotation_interval.clone(),
            si_sra_enable_rdp: input.si_sra_enable_rdp.clone(),
            si_target_name: input.si_target_name.clone(),
            si_user_groups: input.si_user_groups.clone(),
            si_users_ignore: input.si_users_ignore.clone(),
            si_users_path_template: input.si_users_path_template.clone(),
            target_location: input.target_location.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.gateway_create_migration(&req).await {
            Ok(result) => format::format_gateway_create_migration(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_redis operation")]
    async fn gateway_create_producer_redis(&self, Parameters(input): Parameters<GatewayCreateProducerRedisInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerRedis {
            acl_rules: input.acl_rules.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            host: input.host.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            password_length: input.password_length.clone(),
            port: input.port.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            username: input.username.clone(),
        };
        match self.client.gateway_create_producer_redis(&req).await {
            Ok(result) => format::format_gateway_create_producer_redis(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_artifactory operation")]
    async fn gateway_create_producer_artifactory(&self, Parameters(input): Parameters<GatewayCreateProducerArtifactoryInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerArtifactory {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            artifactory_token_audience: input.artifactory_token_audience.clone(),
            artifactory_token_scope: input.artifactory_token_scope.clone(),
            base_url: input.base_url.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_artifactory(&req).await {
            Ok(result) => format::format_gateway_create_producer_artifactory(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_aws operation")]
    async fn gateway_create_producer_aws(&self, Parameters(input): Parameters<GatewayCreateProducerAwsInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerAws {
            access_mode: input.access_mode.clone(),
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            aws_access_key_id: input.aws_access_key_id.clone(),
            aws_access_secret_key: input.aws_access_secret_key.clone(),
            aws_external_id: input.aws_external_id.clone(),
            aws_role_arns: input.aws_role_arns.clone(),
            aws_user_console_access: input.aws_user_console_access.clone(),
            aws_user_groups: input.aws_user_groups.clone(),
            aws_user_policies: input.aws_user_policies.clone(),
            aws_user_programmatic_access: input.aws_user_programmatic_access.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            region: input.region.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            session_tags: input.session_tags.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            transitive_tag_keys: input.transitive_tag_keys.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_aws(&req).await {
            Ok(result) => format::format_gateway_create_producer_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_azure operation")]
    async fn gateway_create_producer_azure(&self, Parameters(input): Parameters<GatewayCreateProducerAzureInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerAzure {
            app_obj_id: input.app_obj_id.clone(),
            azure_administrative_unit: input.azure_administrative_unit.clone(),
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_group_obj_id: input.user_group_obj_id.clone(),
            user_portal_access: input.user_portal_access.clone(),
            user_principal_name: input.user_principal_name.clone(),
            user_programmatic_access: input.user_programmatic_access.clone(),
            user_role_template_id: input.user_role_template_id.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_azure(&req).await {
            Ok(result) => format::format_gateway_create_producer_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_cassandra operation")]
    async fn gateway_create_producer_cassandra(&self, Parameters(input): Parameters<GatewayCreateProducerCassandraInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerCassandra {
            cassandra_creation_statements: input.cassandra_creation_statements.clone(),
            cassandra_hosts: input.cassandra_hosts.clone(),
            cassandra_password: input.cassandra_password.clone(),
            cassandra_port: input.cassandra_port.clone(),
            cassandra_username: input.cassandra_username.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_cassandra(&req).await {
            Ok(result) => format::format_gateway_create_producer_cassandra(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_venafi operation")]
    async fn gateway_create_producer_venafi(&self, Parameters(input): Parameters<GatewayCreateProducerVenafiInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerVenafi {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            allow_subdomains: input.allow_subdomains.clone(),
            allowed_domains: input.allowed_domains.clone(),
            auto_generated_folder: input.auto_generated_folder.clone(),
            delete_protection: input.delete_protection.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            root_first_in_chain: input.root_first_in_chain.clone(),
            sign_using_akeyless_pki: input.sign_using_akeyless_pki.clone(),
            signer_key_name: input.signer_key_name.clone(),
            store_private_key: input.store_private_key.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            venafi_access_token: input.venafi_access_token.clone(),
            venafi_api_key: input.venafi_api_key.clone(),
            venafi_baseurl: input.venafi_baseurl.clone(),
            venafi_client_id: input.venafi_client_id.clone(),
            venafi_refresh_token: input.venafi_refresh_token.clone(),
            venafi_use_tpp: input.venafi_use_tpp.clone(),
            venafi_zone: input.venafi_zone.clone(),
        };
        match self.client.gateway_create_producer_venafi(&req).await {
            Ok(result) => format::format_gateway_create_producer_venafi(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_chef operation")]
    async fn gateway_create_producer_chef(&self, Parameters(input): Parameters<GatewayCreateProducerChefInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerChef {
            chef_orgs: input.chef_orgs.clone(),
            chef_server_key: input.chef_server_key.clone(),
            chef_server_url: input.chef_server_url.clone(),
            chef_server_username: input.chef_server_username.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            skip_ssl: input.skip_ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_chef(&req).await {
            Ok(result) => format::format_gateway_create_producer_chef(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_custom operation")]
    async fn gateway_create_producer_custom(&self, Parameters(input): Parameters<GatewayCreateProducerCustomInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerCustom {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            create_sync_url: input.create_sync_url.clone(),
            delete_protection: input.delete_protection.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            payload: input.payload.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            revoke_sync_url: input.revoke_sync_url.clone(),
            rotate_sync_url: input.rotate_sync_url.clone(),
            tags: input.tags.clone(),
            timeout_sec: input.timeout_sec.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_custom(&req).await {
            Ok(result) => format::format_gateway_create_producer_custom(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_dockerhub operation")]
    async fn gateway_create_producer_dockerhub(&self, Parameters(input): Parameters<GatewayCreateProducerDockerhubInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerDockerhub {
            delete_protection: input.delete_protection.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_token_scopes: input.dockerhub_token_scopes.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_dockerhub(&req).await {
            Ok(result) => format::format_gateway_create_producer_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_eks operation")]
    async fn gateway_create_producer_eks(&self, Parameters(input): Parameters<GatewayCreateProducerEksInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerEks {
            delete_protection: input.delete_protection.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_assume_role: input.eks_assume_role.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_eks(&req).await {
            Ok(result) => format::format_gateway_create_producer_eks(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_gcp operation")]
    async fn gateway_create_producer_gcp(&self, Parameters(input): Parameters<GatewayCreateProducerGcpInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerGcp {
            access_type: input.access_type.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            gcp_cred_type: input.gcp_cred_type.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_key_algo: input.gcp_key_algo.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            gcp_sa_email: input.gcp_sa_email.clone(),
            gcp_token_scopes: input.gcp_token_scopes.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            role_binding: input.role_binding.clone(),
            role_names: input.role_names.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            service_account_type: input.service_account_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_gcp(&req).await {
            Ok(result) => format::format_gateway_create_producer_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_github operation")]
    async fn gateway_create_producer_github(&self, Parameters(input): Parameters<GatewayCreateProducerGithubInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerGithub {
            delete_protection: input.delete_protection.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            installation_id: input.installation_id.clone(),
            installation_organization: input.installation_organization.clone(),
            installation_repository: input.installation_repository.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_permissions: input.token_permissions.clone(),
            token_repositories: input.token_repositories.clone(),
            token_ttl: input.token_ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_create_producer_github(&req).await {
            Ok(result) => format::format_gateway_create_producer_github(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_gke operation")]
    async fn gateway_create_producer_gke(&self, Parameters(input): Parameters<GatewayCreateProducerGkeInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerGke {
            delete_protection: input.delete_protection.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_gke(&req).await {
            Ok(result) => format::format_gateway_create_producer_gke(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_hana_db operation")]
    async fn gateway_create_producer_hana_db(&self, Parameters(input): Parameters<GatewayCreateProducerHanaDbInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerHanaDb {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            hana_dbname: input.hana_dbname.clone(),
            hanadb_create_statements: input.hanadb_create_statements.clone(),
            hanadb_host: input.hanadb_host.clone(),
            hanadb_password: input.hanadb_password.clone(),
            hanadb_port: input.hanadb_port.clone(),
            hanadb_revocation_statements: input.hanadb_revocation_statements.clone(),
            hanadb_username: input.hanadb_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_hana_db(&req).await {
            Ok(result) => format::format_gateway_create_producer_hana_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_native_k8s operation")]
    async fn gateway_create_producer_native_k8s(&self, Parameters(input): Parameters<GatewayCreateProducerNativeK8sInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerNativeK8s {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            k8s_allowed_namespaces: input.k8s_allowed_namespaces.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            k8s_predefined_role_name: input.k8s_predefined_role_name.clone(),
            k8s_predefined_role_type: input.k8s_predefined_role_type.clone(),
            k8s_rolebinding_yaml_data: input.k8s_rolebinding_yaml_data.clone(),
            k8s_rolebinding_yaml_def: input.k8s_rolebinding_yaml_def.clone(),
            k8s_service_account: input.k8s_service_account.clone(),
            k8s_service_account_type: input.k8s_service_account_type.clone(),
            name: input.name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_dashboard_url: input.secure_access_dashboard_url.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_native_k8s(&req).await {
            Ok(result) => format::format_gateway_create_producer_native_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_ldap operation")]
    async fn gateway_create_producer_ldap(&self, Parameters(input): Parameters<GatewayCreateProducerLdapInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerLdap {
            provider_type: input.provider_type.clone(),
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            external_username: input.external_username.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            group_dn: input.group_dn.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            tags: input.tags.clone(),
            target: input.target.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_ldap(&req).await {
            Ok(result) => format::format_gateway_create_producer_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_mongo operation")]
    async fn gateway_create_producer_mongo(&self, Parameters(input): Parameters<GatewayCreateProducerMongoInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerMongo {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_custom_data: input.mongodb_custom_data.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_host_port: input.mongodb_host_port.clone(),
            mongodb_name: input.mongodb_name.clone(),
            mongodb_password: input.mongodb_password.clone(),
            mongodb_roles: input.mongodb_roles.clone(),
            mongodb_scopes: input.mongodb_scopes.clone(),
            mongodb_server_uri: input.mongodb_server_uri.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            mongodb_username: input.mongodb_username.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_mongo(&req).await {
            Ok(result) => format::format_gateway_create_producer_mongo(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_mssql operation")]
    async fn gateway_create_producer_mssql(&self, Parameters(input): Parameters<GatewayCreateProducerMssqlInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerMssql {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mssql_allowed_db_names: input.mssql_allowed_db_names.clone(),
            mssql_create_statements: input.mssql_create_statements.clone(),
            mssql_dbname: input.mssql_dbname.clone(),
            mssql_host: input.mssql_host.clone(),
            mssql_password: input.mssql_password.clone(),
            mssql_port: input.mssql_port.clone(),
            mssql_revocation_statements: input.mssql_revocation_statements.clone(),
            mssql_username: input.mssql_username.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_mssql(&req).await {
            Ok(result) => format::format_gateway_create_producer_mssql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_my_sql operation")]
    async fn gateway_create_producer_my_sql(&self, Parameters(input): Parameters<GatewayCreateProducerMySqlInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerMySql {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mysql_dbname: input.mysql_dbname.clone(),
            mysql_host: input.mysql_host.clone(),
            mysql_password: input.mysql_password.clone(),
            mysql_port: input.mysql_port.clone(),
            mysql_revocation_statements: input.mysql_revocation_statements.clone(),
            mysql_screation_statements: input.mysql_screation_statements.clone(),
            mysql_username: input.mysql_username.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_my_sql(&req).await {
            Ok(result) => format::format_gateway_create_producer_my_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_oracle_db operation")]
    async fn gateway_create_producer_oracle_db(&self, Parameters(input): Parameters<GatewayCreateProducerOracleDbInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerOracleDb {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            oracle_host: input.oracle_host.clone(),
            oracle_password: input.oracle_password.clone(),
            oracle_port: input.oracle_port.clone(),
            oracle_revocation_statements: input.oracle_revocation_statements.clone(),
            oracle_screation_statements: input.oracle_screation_statements.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_username: input.oracle_username.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_oracle_db(&req).await {
            Ok(result) => format::format_gateway_create_producer_oracle_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_ping operation")]
    async fn gateway_create_producer_ping(&self, Parameters(input): Parameters<GatewayCreateProducerPingInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerPing {
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            ping_administrative_port: input.ping_administrative_port.clone(),
            ping_atm_id: input.ping_atm_id.clone(),
            ping_authorization_port: input.ping_authorization_port.clone(),
            ping_cert_subject_dn: input.ping_cert_subject_dn.clone(),
            ping_client_authentication_type: input.ping_client_authentication_type.clone(),
            ping_enforce_replay_prevention: input.ping_enforce_replay_prevention.clone(),
            ping_grant_types: input.ping_grant_types.clone(),
            ping_issuer_dn: input.ping_issuer_dn.clone(),
            ping_jwks: input.ping_jwks.clone(),
            ping_jwks_url: input.ping_jwks_url.clone(),
            ping_password: input.ping_password.clone(),
            ping_privileged_user: input.ping_privileged_user.clone(),
            ping_redirect_uris: input.ping_redirect_uris.clone(),
            ping_restricted_scopes: input.ping_restricted_scopes.clone(),
            ping_signing_algo: input.ping_signing_algo.clone(),
            ping_url: input.ping_url.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_ping(&req).await {
            Ok(result) => format::format_gateway_create_producer_ping(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_postgre_sql operation")]
    async fn gateway_create_producer_postgre_sql(&self, Parameters(input): Parameters<GatewayCreateProducerPostgreSqlInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerPostgreSql {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            postgresql_db_name: input.postgresql_db_name.clone(),
            postgresql_host: input.postgresql_host.clone(),
            postgresql_password: input.postgresql_password.clone(),
            postgresql_port: input.postgresql_port.clone(),
            postgresql_username: input.postgresql_username.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            revocation_statement: input.revocation_statement.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_postgre_sql(&req).await {
            Ok(result) => format::format_gateway_create_producer_postgre_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_rabbit_mq operation")]
    async fn gateway_create_producer_rabbit_mq(&self, Parameters(input): Parameters<GatewayCreateProducerRabbitMqInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerRabbitMq {
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rabbitmq_admin_pwd: input.rabbitmq_admin_pwd.clone(),
            rabbitmq_admin_user: input.rabbitmq_admin_user.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_user_conf_permission: input.rabbitmq_user_conf_permission.clone(),
            rabbitmq_user_read_permission: input.rabbitmq_user_read_permission.clone(),
            rabbitmq_user_tags: input.rabbitmq_user_tags.clone(),
            rabbitmq_user_vhost: input.rabbitmq_user_vhost.clone(),
            rabbitmq_user_write_permission: input.rabbitmq_user_write_permission.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_rabbit_mq(&req).await {
            Ok(result) => format::format_gateway_create_producer_rabbit_mq(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_rdp operation")]
    async fn gateway_create_producer_rdp(&self, Parameters(input): Parameters<GatewayCreateProducerRdpInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerRdp {
            allow_user_extend_session: input.allow_user_extend_session.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rdp_admin_name: input.rdp_admin_name.clone(),
            rdp_admin_pwd: input.rdp_admin_pwd.clone(),
            rdp_host_name: input.rdp_host_name.clone(),
            rdp_host_port: input.rdp_host_port.clone(),
            rdp_user_groups: input.rdp_user_groups.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warn_user_before_expiration: input.warn_user_before_expiration.clone(),
        };
        match self.client.gateway_create_producer_rdp(&req).await {
            Ok(result) => format::format_gateway_create_producer_rdp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_redshift operation")]
    async fn gateway_create_producer_redshift(&self, Parameters(input): Parameters<GatewayCreateProducerRedshiftInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerRedshift {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            redshift_db_name: input.redshift_db_name.clone(),
            redshift_host: input.redshift_host.clone(),
            redshift_password: input.redshift_password.clone(),
            redshift_port: input.redshift_port.clone(),
            redshift_username: input.redshift_username.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_create_producer_redshift(&req).await {
            Ok(result) => format::format_gateway_create_producer_redshift(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_create_producer_snowflake operation")]
    async fn gateway_create_producer_snowflake(&self, Parameters(input): Parameters<GatewayCreateProducerSnowflakeInput>) -> String {
        let req = crate::api::types::GatewayCreateProducerSnowflake {
            account: input.account.clone(),
            account_password: input.account_password.clone(),
            account_username: input.account_username.clone(),
            auth_mode: input.auth_mode.clone(),
            custom_username_template: input.custom_username_template.clone(),
            db_name: input.db_name.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key_algo: input.key_algo.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            private_key: input.private_key.clone(),
            private_key_passphrase: input.private_key_passphrase.clone(),
            role: input.role.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warehouse: input.warehouse.clone(),
        };
        match self.client.gateway_create_producer_snowflake(&req).await {
            Ok(result) => format::format_gateway_create_producer_snowflake(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_delete_allowed_access operation")]
    async fn gateway_delete_allowed_access(&self, Parameters(input): Parameters<GatewayDeleteAllowedAccessInput>) -> String {
        let req = crate::api::types::GatewayDeleteAllowedAccess {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_delete_allowed_access(&req).await {
            Ok(result) => format::format_gateway_delete_allowed_access(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "delete_gateway_allowed_access_id operation")]
    async fn delete_gateway_allowed_access_id(&self, Parameters(input): Parameters<DeleteGatewayAllowedAccessIdInput>) -> String {
        let req = crate::api::types::DeleteGatewayAllowedAccessId {
            access_id: input.access_id.clone(),
            cluster_name: input.cluster_name.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.delete_gateway_allowed_access_id(&req).await {
            Ok(_) => format!("Success: POST /gateway-delete-allowed-management-access"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_delete_k8s_auth_config operation")]
    async fn gateway_delete_k8s_auth_config(&self, Parameters(input): Parameters<GatewayDeleteK8sAuthConfigInput>) -> String {
        let req = crate::api::types::GatewayDeleteK8sAuthConfig {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_delete_k8s_auth_config(&req).await {
            Ok(result) => format::format_gateway_delete_k8s_auth_config(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_delete_migration operation")]
    async fn gateway_delete_migration(&self, Parameters(input): Parameters<GatewayDeleteMigrationInput>) -> String {
        let req = crate::api::types::GatewayDeleteMigration {
            id: input.id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_delete_migration(&req).await {
            Ok(result) => format::format_gateway_delete_migration(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_delete_producer operation")]
    async fn gateway_delete_producer(&self, Parameters(input): Parameters<GatewayDeleteProducerInput>) -> String {
        let req = crate::api::types::GatewayDeleteProducer {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_delete_producer(&req).await {
            Ok(result) => format::format_gateway_delete_producer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_download_customer_fragments operation")]
    async fn gateway_download_customer_fragments(&self, Parameters(input): Parameters<GatewayDownloadCustomerFragmentsInput>) -> String {
        let req = crate::api::types::GatewayDownloadCustomerFragments {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_download_customer_fragments(&req).await {
            Ok(result) => format::format_gateway_download_customer_fragments(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_allowed_access operation")]
    async fn gateway_get_allowed_access(&self, Parameters(input): Parameters<GatewayGetAllowedAccessInput>) -> String {
        let req = crate::api::types::GatewayGetAllowedAccess {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_allowed_access(&req).await {
            Ok(result) => format::format_gateway_get_allowed_access(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_cache operation")]
    async fn gateway_get_cache(&self, Parameters(input): Parameters<GatewayGetCacheInput>) -> String {
        let req = crate::api::types::GatewayGetCache {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_cache(&req).await {
            Ok(result) => format::format_gateway_get_cache(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_config operation")]
    async fn gateway_get_config(&self, Parameters(input): Parameters<GatewayGetConfigInput>) -> String {
        let req = crate::api::types::GatewayGetConfig {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_config(&req).await {
            Ok(result) => format::format_gateway_get_config(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_defaults operation")]
    async fn gateway_get_defaults(&self, Parameters(input): Parameters<GatewayGetDefaultsInput>) -> String {
        let req = crate::api::types::GatewayGetDefaults {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_defaults(&req).await {
            Ok(result) => format::format_gateway_get_defaults(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_k8s_auth_config operation")]
    async fn gateway_get_k8s_auth_config(&self, Parameters(input): Parameters<GatewayGetK8sAuthConfigInput>) -> String {
        let req = crate::api::types::GatewayGetK8sAuthConfig {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_k8s_auth_config(&req).await {
            Ok(result) => format::format_gateway_get_k8s_auth_config(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_ldap_auth_config operation")]
    async fn gateway_get_ldap_auth_config(&self, Parameters(input): Parameters<GatewayGetLdapAuthConfigInput>) -> String {
        let req = crate::api::types::GatewayGetLdapAuthConfig {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_ldap_auth_config(&req).await {
            Ok(result) => format::format_gateway_get_ldap_auth_config(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_log_forwarding operation")]
    async fn gateway_get_log_forwarding(&self, Parameters(input): Parameters<GatewayGetLogForwardingInput>) -> String {
        let req = crate::api::types::GatewayGetLogForwarding {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_log_forwarding(&req).await {
            Ok(result) => format::format_gateway_get_log_forwarding(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_migration operation")]
    async fn gateway_get_migration(&self, Parameters(input): Parameters<GatewayGetMigrationInput>) -> String {
        let req = crate::api::types::GatewayGetMigration {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_migration(&req).await {
            Ok(result) => format::format_gateway_get_migration(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_producer operation")]
    async fn gateway_get_producer(&self, Parameters(input): Parameters<GatewayGetProducerInput>) -> String {
        let req = crate::api::types::GatewayGetProducer {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_producer(&req).await {
            Ok(result) => format::format_gateway_get_producer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_tmp_users operation")]
    async fn gateway_get_tmp_users(&self, Parameters(input): Parameters<GatewayGetTmpUsersInput>) -> String {
        let req = crate::api::types::GatewayGetTmpUsers {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_tmp_users(&req).await {
            Ok(result) => format::format_gateway_get_tmp_users(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_get_remote_access operation")]
    async fn gateway_get_remote_access(&self, Parameters(input): Parameters<GatewayGetRemoteAccessInput>) -> String {
        let req = crate::api::types::GatewayGetRemoteAccess {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_get_remote_access(&req).await {
            Ok(result) => format::format_gateway_get_remote_access(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_list_customer_fragments operation")]
    async fn gateway_list_customer_fragments(&self, Parameters(input): Parameters<GatewayListCustomerFragmentsInput>) -> String {
        let req = crate::api::types::GatewayListCustomerFragments {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_list_customer_fragments(&req).await {
            Ok(result) => format::format_gateway_list_customer_fragments(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_list_migration operation")]
    async fn gateway_list_migration(&self, Parameters(input): Parameters<GatewayListMigrationInput>) -> String {
        let req = crate::api::types::GatewayListMigration {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_list_migration(&req).await {
            Ok(result) => format::format_gateway_list_migration(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_list_producers operation")]
    async fn gateway_list_producers(&self, Parameters(input): Parameters<GatewayListProducersInput>) -> String {
        let req = crate::api::types::GatewayListProducers {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_list_producers(&req).await {
            Ok(result) => format::format_gateway_list_producers(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_list_rotated_secrets operation")]
    async fn gateway_list_rotated_secrets(&self, Parameters(input): Parameters<GatewayListRotatedSecretsInput>) -> String {
        let req = crate::api::types::GatewayListRotatedSecrets {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_list_rotated_secrets(&req).await {
            Ok(result) => format::format_gateway_list_rotated_secrets(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_migrate_personal_items operation")]
    async fn gateway_migrate_personal_items(&self, Parameters(input): Parameters<GatewayMigratePersonalItemsInput>) -> String {
        let req = crate::api::types::GatewayMigratePersonalItems {
            1password_email: input.1password_email.clone(),
            1password_password: input.1password_password.clone(),
            1password_secret_key: input.1password_secret_key.clone(),
            1password_url: input.1password_url.clone(),
            1password_vaults: input.1password_vaults.clone(),
            json: input.json.clone(),
            protection_key: input.protection_key.clone(),
            target_location: input.target_location.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_migrate_personal_items(&req).await {
            Ok(result) => format::format_gateway_migrate_personal_items(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_status_migration operation")]
    async fn gateway_status_migration(&self, Parameters(input): Parameters<GatewayStatusMigrationInput>) -> String {
        let req = crate::api::types::GatewayStatusMigration {
            id: input.id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_status_migration(&req).await {
            Ok(result) => format::format_gateway_status_migration(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_revoke_tmp_users operation")]
    async fn gateway_revoke_tmp_users(&self, Parameters(input): Parameters<GatewayRevokeTmpUsersInput>) -> String {
        let req = crate::api::types::GatewayRevokeTmpUsers {
            host: input.host.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            revoke_all: input.revoke_all.clone(),
            soft_delete: input.soft_delete.clone(),
            tmp_creds_id: input.tmp_creds_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_revoke_tmp_users(&req).await {
            Ok(result) => format::format_gateway_revoke_tmp_users(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotate_secret operation")]
    async fn rotate_secret(&self, Parameters(input): Parameters<RotateSecretInput>) -> String {
        let req = crate::api::types::RotateSecret {
            rotate_all_services_boolean: input.rotate_all_services_boolean.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            rotate_all_services: input.rotate_all_services.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotate_secret(&req).await {
            Ok(result) => format::format_rotate_secret(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_start_producer operation")]
    async fn gateway_start_producer(&self, Parameters(input): Parameters<GatewayStartProducerInput>) -> String {
        let req = crate::api::types::GatewayStartProducer {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_start_producer(&req).await {
            Ok(result) => format::format_gateway_start_producer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_stop_producer operation")]
    async fn gateway_stop_producer(&self, Parameters(input): Parameters<GatewayStopProducerInput>) -> String {
        let req = crate::api::types::GatewayStopProducer {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_stop_producer(&req).await {
            Ok(result) => format::format_gateway_stop_producer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_sync_migration operation")]
    async fn gateway_sync_migration(&self, Parameters(input): Parameters<GatewaySyncMigrationInput>) -> String {
        let req = crate::api::types::GatewaySyncMigration {
            json: input.json.clone(),
            name: input.name.clone(),
            start_sync: input.start_sync.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_sync_migration(&req).await {
            Ok(result) => format::format_gateway_sync_migration(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_allowed_access operation")]
    async fn gateway_update_allowed_access(&self, Parameters(input): Parameters<GatewayUpdateAllowedAccessInput>) -> String {
        let req = crate::api::types::GatewayUpdateAllowedAccess {
            sub_claims_case_insensitive: input.sub_claims_case_insensitive.clone(),
            access_id: input.access_id.clone(),
            case_sensitive: input.case_sensitive.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            permissions: input.permissions.clone(),
            sub_claims: input.sub_claims.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_allowed_access(&req).await {
            Ok(result) => format::format_gateway_update_allowed_access(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_cache operation")]
    async fn gateway_update_cache(&self, Parameters(input): Parameters<GatewayUpdateCacheInput>) -> String {
        let req = crate::api::types::GatewayUpdateCache {
            backup_interval: input.backup_interval.clone(),
            enable_cache: input.enable_cache.clone(),
            enable_proactive: input.enable_proactive.clone(),
            json: input.json.clone(),
            minimum_fetch_interval: input.minimum_fetch_interval.clone(),
            stale_timeout: input.stale_timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_cache(&req).await {
            Ok(result) => format::format_gateway_update_cache(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_defaults operation")]
    async fn gateway_update_defaults(&self, Parameters(input): Parameters<GatewayUpdateDefaultsInput>) -> String {
        let req = crate::api::types::GatewayUpdateDefaults {
            cert_access_id: input.cert_access_id.clone(),
            event_on_status_change: input.event_on_status_change.clone(),
            hvp_route_version: input.hvp_route_version.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            oidc_access_id: input.oidc_access_id.clone(),
            saml_access_id: input.saml_access_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_defaults(&req).await {
            Ok(result) => format::format_gateway_update_defaults(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_item operation")]
    async fn gateway_update_item(&self, Parameters(input): Parameters<GatewayUpdateItemInput>) -> String {
        let req = crate::api::types::GatewayUpdateItem {
            add_tag: input.add_tag.clone(),
            api_id: input.api_id.clone(),
            api_key: input.api_key.clone(),
            app_id: input.app_id.clone(),
            auto_rotate: input.auto_rotate.clone(),
            custom_payload: input.custom_payload.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_service_account_email: input.gcp_service_account_email.clone(),
            gcp_service_account_key_id: input.gcp_service_account_key_id.clone(),
            grace_rotation: input.grace_rotation.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            new_metadata: input.new_metadata.clone(),
            new_name: input.new_name.clone(),
            new_version: input.new_version.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_creds_type: input.rotator_creds_type.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_item(&req).await {
            Ok(result) => format::format_gateway_update_item(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_k8s_auth_config operation")]
    async fn gateway_update_k8s_auth_config(&self, Parameters(input): Parameters<GatewayUpdateK8sAuthConfigInput>) -> String {
        let req = crate::api::types::GatewayUpdateK8sAuthConfig {
            access_id: input.access_id.clone(),
            cluster_api_type: input.cluster_api_type.clone(),
            disable_issuer_validation: input.disable_issuer_validation.clone(),
            json: input.json.clone(),
            k8s_auth_type: input.k8s_auth_type.clone(),
            k8s_ca_cert: input.k8s_ca_cert.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_host: input.k8s_host.clone(),
            k8s_issuer: input.k8s_issuer.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            rancher_api_key: input.rancher_api_key.clone(),
            rancher_cluster_id: input.rancher_cluster_id.clone(),
            signing_key: input.signing_key.clone(),
            token: input.token.clone(),
            token_exp: input.token_exp.clone(),
            token_reviewer_jwt: input.token_reviewer_jwt.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
        };
        match self.client.gateway_update_k8s_auth_config(&req).await {
            Ok(result) => format::format_gateway_update_k8s_auth_config(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_ldap_auth_config operation")]
    async fn gateway_update_ldap_auth_config(&self, Parameters(input): Parameters<GatewayUpdateLdapAuthConfigInput>) -> String {
        let req = crate::api::types::GatewayUpdateLdapAuthConfig {
            access_id: input.access_id.clone(),
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            group_attr: input.group_attr.clone(),
            group_dn: input.group_dn.clone(),
            group_filter: input.group_filter.clone(),
            json: input.json.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_enable: input.ldap_enable.clone(),
            ldap_url: input.ldap_url.clone(),
            signing_key_data: input.signing_key_data.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
        };
        match self.client.gateway_update_ldap_auth_config(&req).await {
            Ok(result) => format::format_gateway_update_ldap_auth_config(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_aws_s3 operation")]
    async fn gateway_update_log_forwarding_aws_s3(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingAwsS3Input>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingAwsS3 {
            access_id: input.access_id.clone(),
            access_key: input.access_key.clone(),
            auth_type: input.auth_type.clone(),
            bucket_name: input.bucket_name.clone(),
            enable: input.enable.clone(),
            json: input.json.clone(),
            log_folder: input.log_folder.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            region: input.region.clone(),
            role_arn: input.role_arn.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_aws_s3(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_aws_s3(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_azure_analytics operation")]
    async fn gateway_update_log_forwarding_azure_analytics(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingAzureAnalyticsInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingAzureAnalytics {
            enable: input.enable.clone(),
            enable_batch: input.enable_batch.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            workspace_id: input.workspace_id.clone(),
            workspace_key: input.workspace_key.clone(),
        };
        match self.client.gateway_update_log_forwarding_azure_analytics(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_azure_analytics(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_datadog operation")]
    async fn gateway_update_log_forwarding_datadog(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingDatadogInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingDatadog {
            api_key: input.api_key.clone(),
            enable: input.enable.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            log_service: input.log_service.clone(),
            log_source: input.log_source.clone(),
            log_tags: input.log_tags.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_datadog(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_datadog(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_elasticsearch operation")]
    async fn gateway_update_log_forwarding_elasticsearch(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingElasticsearchInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingElasticsearch {
            api_key: input.api_key.clone(),
            auth_type: input.auth_type.clone(),
            cloud_id: input.cloud_id.clone(),
            enable: input.enable.clone(),
            enable_tls: input.enable_tls.clone(),
            index: input.index.clone(),
            json: input.json.clone(),
            nodes: input.nodes.clone(),
            output_format: input.output_format.clone(),
            password: input.password.clone(),
            pull_interval: input.pull_interval.clone(),
            server_type: input.server_type.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_name: input.user_name.clone(),
        };
        match self.client.gateway_update_log_forwarding_elasticsearch(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_elasticsearch(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_google_chronicle operation")]
    async fn gateway_update_log_forwarding_google_chronicle(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingGoogleChronicleInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingGoogleChronicle {
            customer_id: input.customer_id.clone(),
            enable: input.enable.clone(),
            gcp_key: input.gcp_key.clone(),
            json: input.json.clone(),
            log_type: input.log_type.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            region: input.region.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_google_chronicle(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_google_chronicle(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_logstash operation")]
    async fn gateway_update_log_forwarding_logstash(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingLogstashInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingLogstash {
            dns: input.dns.clone(),
            enable: input.enable.clone(),
            enable_tls: input.enable_tls.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            protocol: input.protocol.clone(),
            pull_interval: input.pull_interval.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_logstash(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_logstash(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_logz_io operation")]
    async fn gateway_update_log_forwarding_logz_io(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingLogzIoInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingLogzIo {
            enable: input.enable.clone(),
            json: input.json.clone(),
            logz_io_token: input.logz_io_token.clone(),
            output_format: input.output_format.clone(),
            protocol: input.protocol.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_logz_io(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_logz_io(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_splunk operation")]
    async fn gateway_update_log_forwarding_splunk(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingSplunkInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingSplunk {
            enable: input.enable.clone(),
            enable_batch: input.enable_batch.clone(),
            enable_tls: input.enable_tls.clone(),
            index: input.index.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            source: input.source.clone(),
            source_type: input.source_type.clone(),
            splunk_token: input.splunk_token.clone(),
            splunk_url: input.splunk_url.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_splunk(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_splunk(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_stdout operation")]
    async fn gateway_update_log_forwarding_stdout(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingStdoutInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingStdout {
            enable: input.enable.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_stdout(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_stdout(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_sumologic operation")]
    async fn gateway_update_log_forwarding_sumologic(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingSumologicInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingSumologic {
            enable: input.enable.clone(),
            endpoint: input.endpoint.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            sumologic_tags: input.sumologic_tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_sumologic(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_sumologic(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_log_forwarding_syslog operation")]
    async fn gateway_update_log_forwarding_syslog(&self, Parameters(input): Parameters<GatewayUpdateLogForwardingSyslogInput>) -> String {
        let req = crate::api::types::GatewayUpdateLogForwardingSyslog {
            enable: input.enable.clone(),
            enable_tls: input.enable_tls.clone(),
            formatter: input.formatter.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            network: input.network.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            target_tag: input.target_tag.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_log_forwarding_syslog(&req).await {
            Ok(result) => format::format_gateway_update_log_forwarding_syslog(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_migration operation")]
    async fn gateway_update_migration(&self, Parameters(input): Parameters<GatewayUpdateMigrationInput>) -> String {
        let req = crate::api::types::GatewayUpdateMigration {
            service_account_key_decoded: input.service_account_key_decoded.clone(),
            ad_auto_rotate: input.ad_auto_rotate.clone(),
            ad_cert_expiration_event_in: input.ad_cert_expiration_event_in.clone(),
            ad_certificates_path_template: input.ad_certificates_path_template.clone(),
            ad_computer_base_dn: input.ad_computer_base_dn.clone(),
            ad_discover_iis_app: input.ad_discover_iis_app.clone(),
            ad_discover_services: input.ad_discover_services.clone(),
            ad_discovery_types: input.ad_discovery_types.clone(),
            ad_domain_name: input.ad_domain_name.clone(),
            ad_domain_users_path_template: input.ad_domain_users_path_template.clone(),
            ad_local_users_ignore: input.ad_local_users_ignore.clone(),
            ad_local_users_path_template: input.ad_local_users_path_template.clone(),
            ad_os_filter: input.ad_os_filter.clone(),
            ad_rotation_hour: input.ad_rotation_hour.clone(),
            ad_rotation_interval: input.ad_rotation_interval.clone(),
            ad_sra_enable_rdp: input.ad_sra_enable_rdp.clone(),
            ad_ssh_port: input.ad_ssh_port.clone(),
            ad_target_format: input.ad_target_format.clone(),
            ad_target_name: input.ad_target_name.clone(),
            ad_targets_path_template: input.ad_targets_path_template.clone(),
            ad_targets_type: input.ad_targets_type.clone(),
            ad_user_base_dn: input.ad_user_base_dn.clone(),
            ad_user_groups: input.ad_user_groups.clone(),
            ad_winrm_over_http: input.ad_winrm_over_http.clone(),
            ad_winrm_port: input.ad_winrm_port.clone(),
            ad_discover_local_users: input.ad_discover_local_users.clone(),
            ai_certificate_discovery: input.ai_certificate_discovery.clone(),
            aws_key: input.aws_key.clone(),
            aws_key_id: input.aws_key_id.clone(),
            aws_region: input.aws_region.clone(),
            azure_client_id: input.azure_client_id.clone(),
            azure_kv_name: input.azure_kv_name.clone(),
            azure_secret: input.azure_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            conjur_account: input.conjur_account.clone(),
            conjur_api_key: input.conjur_api_key.clone(),
            conjur_url: input.conjur_url.clone(),
            conjur_username: input.conjur_username.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            hashi_json: input.hashi_json.clone(),
            hashi_ns: input.hashi_ns.clone(),
            hashi_token: input.hashi_token.clone(),
            hashi_url: input.hashi_url.clone(),
            hosts: input.hosts.clone(),
            id: input.id.clone(),
            json: input.json.clone(),
            k8s_ca_certificate: input.k8s_ca_certificate.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            k8s_password: input.k8s_password.clone(),
            k8s_skip_system: input.k8s_skip_system.clone(),
            k8s_token: input.k8s_token.clone(),
            k8s_url: input.k8s_url.clone(),
            k8s_username: input.k8s_username.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            port_ranges: input.port_ranges.clone(),
            protection_key: input.protection_key.clone(),
            si_auto_rotate: input.si_auto_rotate.clone(),
            si_rotation_hour: input.si_rotation_hour.clone(),
            si_rotation_interval: input.si_rotation_interval.clone(),
            si_sra_enable_rdp: input.si_sra_enable_rdp.clone(),
            si_target_name: input.si_target_name.clone(),
            si_user_groups: input.si_user_groups.clone(),
            si_users_ignore: input.si_users_ignore.clone(),
            si_users_path_template: input.si_users_path_template.clone(),
            target_location: input.target_location.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.gateway_update_migration(&req).await {
            Ok(result) => format::format_gateway_update_migration(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_artifactory operation")]
    async fn gateway_update_producer_artifactory(&self, Parameters(input): Parameters<GatewayUpdateProducerArtifactoryInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerArtifactory {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            artifactory_token_audience: input.artifactory_token_audience.clone(),
            artifactory_token_scope: input.artifactory_token_scope.clone(),
            base_url: input.base_url.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_artifactory(&req).await {
            Ok(result) => format::format_gateway_update_producer_artifactory(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_aws operation")]
    async fn gateway_update_producer_aws(&self, Parameters(input): Parameters<GatewayUpdateProducerAwsInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerAws {
            access_mode: input.access_mode.clone(),
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            aws_access_key_id: input.aws_access_key_id.clone(),
            aws_access_secret_key: input.aws_access_secret_key.clone(),
            aws_external_id: input.aws_external_id.clone(),
            aws_role_arns: input.aws_role_arns.clone(),
            aws_user_console_access: input.aws_user_console_access.clone(),
            aws_user_groups: input.aws_user_groups.clone(),
            aws_user_policies: input.aws_user_policies.clone(),
            aws_user_programmatic_access: input.aws_user_programmatic_access.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            region: input.region.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            session_tags: input.session_tags.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            transitive_tag_keys: input.transitive_tag_keys.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_aws(&req).await {
            Ok(result) => format::format_gateway_update_producer_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_azure operation")]
    async fn gateway_update_producer_azure(&self, Parameters(input): Parameters<GatewayUpdateProducerAzureInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerAzure {
            app_obj_id: input.app_obj_id.clone(),
            azure_administrative_unit: input.azure_administrative_unit.clone(),
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_group_obj_id: input.user_group_obj_id.clone(),
            user_portal_access: input.user_portal_access.clone(),
            user_principal_name: input.user_principal_name.clone(),
            user_programmatic_access: input.user_programmatic_access.clone(),
            user_role_template_id: input.user_role_template_id.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_azure(&req).await {
            Ok(result) => format::format_gateway_update_producer_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_cassandra operation")]
    async fn gateway_update_producer_cassandra(&self, Parameters(input): Parameters<GatewayUpdateProducerCassandraInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerCassandra {
            cassandra_creation_statements: input.cassandra_creation_statements.clone(),
            cassandra_hosts: input.cassandra_hosts.clone(),
            cassandra_password: input.cassandra_password.clone(),
            cassandra_port: input.cassandra_port.clone(),
            cassandra_username: input.cassandra_username.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_cassandra(&req).await {
            Ok(result) => format::format_gateway_update_producer_cassandra(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_venafi operation")]
    async fn gateway_update_producer_venafi(&self, Parameters(input): Parameters<GatewayUpdateProducerVenafiInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerVenafi {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            allow_subdomains: input.allow_subdomains.clone(),
            allowed_domains: input.allowed_domains.clone(),
            auto_generated_folder: input.auto_generated_folder.clone(),
            delete_protection: input.delete_protection.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            root_first_in_chain: input.root_first_in_chain.clone(),
            sign_using_akeyless_pki: input.sign_using_akeyless_pki.clone(),
            signer_key_name: input.signer_key_name.clone(),
            store_private_key: input.store_private_key.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            venafi_access_token: input.venafi_access_token.clone(),
            venafi_api_key: input.venafi_api_key.clone(),
            venafi_baseurl: input.venafi_baseurl.clone(),
            venafi_client_id: input.venafi_client_id.clone(),
            venafi_refresh_token: input.venafi_refresh_token.clone(),
            venafi_use_tpp: input.venafi_use_tpp.clone(),
            venafi_zone: input.venafi_zone.clone(),
        };
        match self.client.gateway_update_producer_venafi(&req).await {
            Ok(result) => format::format_gateway_update_producer_venafi(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_chef operation")]
    async fn gateway_update_producer_chef(&self, Parameters(input): Parameters<GatewayUpdateProducerChefInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerChef {
            chef_orgs: input.chef_orgs.clone(),
            chef_server_key: input.chef_server_key.clone(),
            chef_server_url: input.chef_server_url.clone(),
            chef_server_username: input.chef_server_username.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            skip_ssl: input.skip_ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_chef(&req).await {
            Ok(result) => format::format_gateway_update_producer_chef(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_custom operation")]
    async fn gateway_update_producer_custom(&self, Parameters(input): Parameters<GatewayUpdateProducerCustomInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerCustom {
            admin_rotation_interval_days: input.admin_rotation_interval_days.clone(),
            create_sync_url: input.create_sync_url.clone(),
            delete_protection: input.delete_protection.clone(),
            enable_admin_rotation: input.enable_admin_rotation.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            payload: input.payload.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            revoke_sync_url: input.revoke_sync_url.clone(),
            rotate_sync_url: input.rotate_sync_url.clone(),
            tags: input.tags.clone(),
            timeout_sec: input.timeout_sec.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_custom(&req).await {
            Ok(result) => format::format_gateway_update_producer_custom(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_dockerhub operation")]
    async fn gateway_update_producer_dockerhub(&self, Parameters(input): Parameters<GatewayUpdateProducerDockerhubInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerDockerhub {
            delete_protection: input.delete_protection.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_token_scopes: input.dockerhub_token_scopes.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_dockerhub(&req).await {
            Ok(result) => format::format_gateway_update_producer_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_eks operation")]
    async fn gateway_update_producer_eks(&self, Parameters(input): Parameters<GatewayUpdateProducerEksInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerEks {
            delete_protection: input.delete_protection.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_assume_role: input.eks_assume_role.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_eks(&req).await {
            Ok(result) => format::format_gateway_update_producer_eks(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_gcp operation")]
    async fn gateway_update_producer_gcp(&self, Parameters(input): Parameters<GatewayUpdateProducerGcpInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerGcp {
            access_type: input.access_type.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            gcp_cred_type: input.gcp_cred_type.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_key_algo: input.gcp_key_algo.clone(),
            gcp_project_id: input.gcp_project_id.clone(),
            gcp_sa_email: input.gcp_sa_email.clone(),
            gcp_token_scopes: input.gcp_token_scopes.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            role_binding: input.role_binding.clone(),
            role_names: input.role_names.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            service_account_type: input.service_account_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_gcp(&req).await {
            Ok(result) => format::format_gateway_update_producer_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_github operation")]
    async fn gateway_update_producer_github(&self, Parameters(input): Parameters<GatewayUpdateProducerGithubInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerGithub {
            delete_protection: input.delete_protection.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            installation_id: input.installation_id.clone(),
            installation_organization: input.installation_organization.clone(),
            installation_repository: input.installation_repository.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_permissions: input.token_permissions.clone(),
            token_repositories: input.token_repositories.clone(),
            token_ttl: input.token_ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_producer_github(&req).await {
            Ok(result) => format::format_gateway_update_producer_github(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_gke operation")]
    async fn gateway_update_producer_gke(&self, Parameters(input): Parameters<GatewayUpdateProducerGkeInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerGke {
            delete_protection: input.delete_protection.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_gke(&req).await {
            Ok(result) => format::format_gateway_update_producer_gke(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_hana_db operation")]
    async fn gateway_update_producer_hana_db(&self, Parameters(input): Parameters<GatewayUpdateProducerHanaDbInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerHanaDb {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            hana_dbname: input.hana_dbname.clone(),
            hanadb_create_statements: input.hanadb_create_statements.clone(),
            hanadb_host: input.hanadb_host.clone(),
            hanadb_password: input.hanadb_password.clone(),
            hanadb_port: input.hanadb_port.clone(),
            hanadb_revocation_statements: input.hanadb_revocation_statements.clone(),
            hanadb_username: input.hanadb_username.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_hana_db(&req).await {
            Ok(result) => format::format_gateway_update_producer_hana_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_native_k8s operation")]
    async fn gateway_update_producer_native_k8s(&self, Parameters(input): Parameters<GatewayUpdateProducerNativeK8sInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerNativeK8s {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            k8s_allowed_namespaces: input.k8s_allowed_namespaces.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            k8s_namespace: input.k8s_namespace.clone(),
            k8s_predefined_role_name: input.k8s_predefined_role_name.clone(),
            k8s_predefined_role_type: input.k8s_predefined_role_type.clone(),
            k8s_rolebinding_yaml_data: input.k8s_rolebinding_yaml_data.clone(),
            k8s_rolebinding_yaml_def: input.k8s_rolebinding_yaml_def.clone(),
            k8s_service_account: input.k8s_service_account.clone(),
            k8s_service_account_type: input.k8s_service_account_type.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_dashboard_url: input.secure_access_dashboard_url.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_native_k8s(&req).await {
            Ok(result) => format::format_gateway_update_producer_native_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_ldap operation")]
    async fn gateway_update_producer_ldap(&self, Parameters(input): Parameters<GatewayUpdateProducerLdapInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerLdap {
            provider_type: input.provider_type.clone(),
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            external_username: input.external_username.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            group_dn: input.group_dn.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            tags: input.tags.clone(),
            target: input.target.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_ldap(&req).await {
            Ok(result) => format::format_gateway_update_producer_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_mongo operation")]
    async fn gateway_update_producer_mongo(&self, Parameters(input): Parameters<GatewayUpdateProducerMongoInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerMongo {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_custom_data: input.mongodb_custom_data.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_host_port: input.mongodb_host_port.clone(),
            mongodb_name: input.mongodb_name.clone(),
            mongodb_password: input.mongodb_password.clone(),
            mongodb_roles: input.mongodb_roles.clone(),
            mongodb_scopes: input.mongodb_scopes.clone(),
            mongodb_server_uri: input.mongodb_server_uri.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            mongodb_username: input.mongodb_username.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_mongo(&req).await {
            Ok(result) => format::format_gateway_update_producer_mongo(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_mssql operation")]
    async fn gateway_update_producer_mssql(&self, Parameters(input): Parameters<GatewayUpdateProducerMssqlInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerMssql {
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mssql_allowed_db_names: input.mssql_allowed_db_names.clone(),
            mssql_create_statements: input.mssql_create_statements.clone(),
            mssql_dbname: input.mssql_dbname.clone(),
            mssql_host: input.mssql_host.clone(),
            mssql_password: input.mssql_password.clone(),
            mssql_port: input.mssql_port.clone(),
            mssql_revocation_statements: input.mssql_revocation_statements.clone(),
            mssql_username: input.mssql_username.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_mssql(&req).await {
            Ok(result) => format::format_gateway_update_producer_mssql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_my_sql operation")]
    async fn gateway_update_producer_my_sql(&self, Parameters(input): Parameters<GatewayUpdateProducerMySqlInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerMySql {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            mysql_dbname: input.mysql_dbname.clone(),
            mysql_host: input.mysql_host.clone(),
            mysql_password: input.mysql_password.clone(),
            mysql_port: input.mysql_port.clone(),
            mysql_revocation_statements: input.mysql_revocation_statements.clone(),
            mysql_screation_statements: input.mysql_screation_statements.clone(),
            mysql_username: input.mysql_username.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_my_sql(&req).await {
            Ok(result) => format::format_gateway_update_producer_my_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_oracle_db operation")]
    async fn gateway_update_producer_oracle_db(&self, Parameters(input): Parameters<GatewayUpdateProducerOracleDbInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerOracleDb {
            custom_username_template: input.custom_username_template.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            oracle_host: input.oracle_host.clone(),
            oracle_password: input.oracle_password.clone(),
            oracle_port: input.oracle_port.clone(),
            oracle_revocation_statements: input.oracle_revocation_statements.clone(),
            oracle_screation_statements: input.oracle_screation_statements.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_username: input.oracle_username.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_oracle_db(&req).await {
            Ok(result) => format::format_gateway_update_producer_oracle_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_ping operation")]
    async fn gateway_update_producer_ping(&self, Parameters(input): Parameters<GatewayUpdateProducerPingInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerPing {
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            ping_administrative_port: input.ping_administrative_port.clone(),
            ping_atm_id: input.ping_atm_id.clone(),
            ping_authorization_port: input.ping_authorization_port.clone(),
            ping_cert_subject_dn: input.ping_cert_subject_dn.clone(),
            ping_client_authentication_type: input.ping_client_authentication_type.clone(),
            ping_enforce_replay_prevention: input.ping_enforce_replay_prevention.clone(),
            ping_grant_types: input.ping_grant_types.clone(),
            ping_issuer_dn: input.ping_issuer_dn.clone(),
            ping_jwks: input.ping_jwks.clone(),
            ping_jwks_url: input.ping_jwks_url.clone(),
            ping_password: input.ping_password.clone(),
            ping_privileged_user: input.ping_privileged_user.clone(),
            ping_redirect_uris: input.ping_redirect_uris.clone(),
            ping_restricted_scopes: input.ping_restricted_scopes.clone(),
            ping_signing_algo: input.ping_signing_algo.clone(),
            ping_url: input.ping_url.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_ping(&req).await {
            Ok(result) => format::format_gateway_update_producer_ping(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_postgre_sql operation")]
    async fn gateway_update_producer_postgre_sql(&self, Parameters(input): Parameters<GatewayUpdateProducerPostgreSqlInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerPostgreSql {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            postgresql_db_name: input.postgresql_db_name.clone(),
            postgresql_host: input.postgresql_host.clone(),
            postgresql_password: input.postgresql_password.clone(),
            postgresql_port: input.postgresql_port.clone(),
            postgresql_username: input.postgresql_username.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            revocation_statement: input.revocation_statement.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_postgre_sql(&req).await {
            Ok(result) => format::format_gateway_update_producer_postgre_sql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_rabbit_mq operation")]
    async fn gateway_update_producer_rabbit_mq(&self, Parameters(input): Parameters<GatewayUpdateProducerRabbitMqInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerRabbitMq {
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rabbitmq_admin_pwd: input.rabbitmq_admin_pwd.clone(),
            rabbitmq_admin_user: input.rabbitmq_admin_user.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_user_conf_permission: input.rabbitmq_user_conf_permission.clone(),
            rabbitmq_user_read_permission: input.rabbitmq_user_read_permission.clone(),
            rabbitmq_user_tags: input.rabbitmq_user_tags.clone(),
            rabbitmq_user_vhost: input.rabbitmq_user_vhost.clone(),
            rabbitmq_user_write_permission: input.rabbitmq_user_write_permission.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_rabbit_mq(&req).await {
            Ok(result) => format::format_gateway_update_producer_rabbit_mq(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_rdp operation")]
    async fn gateway_update_producer_rdp(&self, Parameters(input): Parameters<GatewayUpdateProducerRdpInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerRdp {
            allow_user_extend_session: input.allow_user_extend_session.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            fixed_user_only: input.fixed_user_only.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            rdp_admin_name: input.rdp_admin_name.clone(),
            rdp_admin_pwd: input.rdp_admin_pwd.clone(),
            rdp_host_name: input.rdp_host_name.clone(),
            rdp_host_port: input.rdp_host_port.clone(),
            rdp_user_groups: input.rdp_user_groups.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_delay: input.secure_access_delay.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warn_user_before_expiration: input.warn_user_before_expiration.clone(),
        };
        match self.client.gateway_update_producer_rdp(&req).await {
            Ok(result) => format::format_gateway_update_producer_rdp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_redis operation")]
    async fn gateway_update_producer_redis(&self, Parameters(input): Parameters<GatewayUpdateProducerRedisInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerRedis {
            acl_rules: input.acl_rules.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            host: input.host.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            password_length: input.password_length.clone(),
            port: input.port.clone(),
            producer_encryption_key_name: input.producer_encryption_key_name.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            username: input.username.clone(),
        };
        match self.client.gateway_update_producer_redis(&req).await {
            Ok(result) => format::format_gateway_update_producer_redis(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_redshift operation")]
    async fn gateway_update_producer_redshift(&self, Parameters(input): Parameters<GatewayUpdateProducerRedshiftInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerRedshift {
            creation_statements: input.creation_statements.clone(),
            custom_username_template: input.custom_username_template.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            producer_encryption_key: input.producer_encryption_key.clone(),
            redshift_db_name: input.redshift_db_name.clone(),
            redshift_host: input.redshift_host.clone(),
            redshift_password: input.redshift_password.clone(),
            redshift_port: input.redshift_port.clone(),
            redshift_username: input.redshift_username.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            ssl: input.ssl.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
        };
        match self.client.gateway_update_producer_redshift(&req).await {
            Ok(result) => format::format_gateway_update_producer_redshift(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_producer_snowflake operation")]
    async fn gateway_update_producer_snowflake(&self, Parameters(input): Parameters<GatewayUpdateProducerSnowflakeInput>) -> String {
        let req = crate::api::types::GatewayUpdateProducerSnowflake {
            account: input.account.clone(),
            account_password: input.account_password.clone(),
            account_username: input.account_username.clone(),
            auth_mode: input.auth_mode.clone(),
            custom_username_template: input.custom_username_template.clone(),
            db_name: input.db_name.clone(),
            delete_protection: input.delete_protection.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key_algo: input.key_algo.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            private_key: input.private_key.clone(),
            private_key_passphrase: input.private_key_passphrase.clone(),
            role: input.role.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_ttl: input.user_ttl.clone(),
            warehouse: input.warehouse.clone(),
        };
        match self.client.gateway_update_producer_snowflake(&req).await {
            Ok(result) => format::format_gateway_update_producer_snowflake(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_tmp_users operation")]
    async fn gateway_update_tmp_users(&self, Parameters(input): Parameters<GatewayUpdateTmpUsersInput>) -> String {
        let req = crate::api::types::GatewayUpdateTmpUsers {
            host: input.host.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_ttl_min: input.new_ttl_min.clone(),
            tmp_creds_id: input.tmp_creds_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_tmp_users(&req).await {
            Ok(result) => format::format_gateway_update_tmp_users(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_remote_access operation")]
    async fn gateway_update_remote_access(&self, Parameters(input): Parameters<GatewayUpdateRemoteAccessInput>) -> String {
        let req = crate::api::types::GatewayUpdateRemoteAccess {
            allowed_ssh_url: input.allowed_ssh_url.clone(),
            allowed_urls: input.allowed_urls.clone(),
            default_session_ttl_minutes: input.default_session_ttl_minutes.clone(),
            hide_session_recording: input.hide_session_recording.clone(),
            json: input.json.clone(),
            kexalgs: input.kexalgs.clone(),
            keyboard_layout: input.keyboard_layout.clone(),
            legacy_ssh_algorithm: input.legacy_ssh_algorithm.clone(),
            rdp_target_configuration: input.rdp_target_configuration.clone(),
            ssh_target_configuration: input.ssh_target_configuration.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_remote_access(&req).await {
            Ok(result) => format::format_gateway_update_remote_access(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_remote_access_desktop_app operation")]
    async fn gateway_update_remote_access_desktop_app(&self, Parameters(input): Parameters<GatewayUpdateRemoteAccessDesktopAppInput>) -> String {
        let req = crate::api::types::GatewayUpdateRemoteAccessDesktopApp {
            desktop_app_secure_web_access_url: input.desktop_app_secure_web_access_url.clone(),
            desktop_app_secure_web_proxy: input.desktop_app_secure_web_proxy.clone(),
            desktop_app_ssh_cert_issuer: input.desktop_app_ssh_cert_issuer.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_remote_access_desktop_app(&req).await {
            Ok(result) => format::format_gateway_update_remote_access_desktop_app(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_remote_access_rdp_recordings operation")]
    async fn gateway_update_remote_access_rdp_recordings(&self, Parameters(input): Parameters<GatewayUpdateRemoteAccessRdpRecordingsInput>) -> String {
        let req = crate::api::types::GatewayUpdateRemoteAccessRdpRecordings {
            aws_storage_access_key_id: input.aws_storage_access_key_id.clone(),
            aws_storage_bucket_name: input.aws_storage_bucket_name.clone(),
            aws_storage_bucket_prefix: input.aws_storage_bucket_prefix.clone(),
            aws_storage_region: input.aws_storage_region.clone(),
            aws_storage_secret_access_key: input.aws_storage_secret_access_key.clone(),
            azure_storage_account_name: input.azure_storage_account_name.clone(),
            azure_storage_client_id: input.azure_storage_client_id.clone(),
            azure_storage_client_secret: input.azure_storage_client_secret.clone(),
            azure_storage_container_name: input.azure_storage_container_name.clone(),
            azure_storage_tenant_id: input.azure_storage_tenant_id.clone(),
            json: input.json.clone(),
            rdp_session_recording: input.rdp_session_recording.clone(),
            rdp_session_recording_compress: input.rdp_session_recording_compress.clone(),
            rdp_session_recording_encryption_key: input.rdp_session_recording_encryption_key.clone(),
            rdp_session_recording_quality: input.rdp_session_recording_quality.clone(),
            rdp_session_storage: input.rdp_session_storage.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_remote_access_rdp_recordings(&req).await {
            Ok(result) => format::format_gateway_update_remote_access_rdp_recordings(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_aws_s3 operation")]
    async fn gw_update_remote_access_session_logs_aws_s3(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsAwsS3Input>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsAwsS3 {
            access_id: input.access_id.clone(),
            access_key: input.access_key.clone(),
            auth_type: input.auth_type.clone(),
            bucket_name: input.bucket_name.clone(),
            enable: input.enable.clone(),
            json: input.json.clone(),
            log_folder: input.log_folder.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            region: input.region.clone(),
            role_arn: input.role_arn.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_aws_s3(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_aws_s3(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_azure_analytics operation")]
    async fn gw_update_remote_access_session_logs_azure_analytics(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsAzureAnalyticsInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsAzureAnalytics {
            enable: input.enable.clone(),
            enable_batch: input.enable_batch.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            workspace_id: input.workspace_id.clone(),
            workspace_key: input.workspace_key.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_azure_analytics(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_azure_analytics(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_datadog operation")]
    async fn gw_update_remote_access_session_logs_datadog(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsDatadogInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsDatadog {
            api_key: input.api_key.clone(),
            enable: input.enable.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            log_service: input.log_service.clone(),
            log_source: input.log_source.clone(),
            log_tags: input.log_tags.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_datadog(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_datadog(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_elasticsearch operation")]
    async fn gw_update_remote_access_session_logs_elasticsearch(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsElasticsearchInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsElasticsearch {
            api_key: input.api_key.clone(),
            auth_type: input.auth_type.clone(),
            cloud_id: input.cloud_id.clone(),
            enable: input.enable.clone(),
            enable_tls: input.enable_tls.clone(),
            index: input.index.clone(),
            json: input.json.clone(),
            nodes: input.nodes.clone(),
            output_format: input.output_format.clone(),
            password: input.password.clone(),
            pull_interval: input.pull_interval.clone(),
            server_type: input.server_type.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_name: input.user_name.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_elasticsearch(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_elasticsearch(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_google_chronicle operation")]
    async fn gw_update_remote_access_session_logs_google_chronicle(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsGoogleChronicleInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsGoogleChronicle {
            customer_id: input.customer_id.clone(),
            enable: input.enable.clone(),
            gcp_key: input.gcp_key.clone(),
            json: input.json.clone(),
            log_type: input.log_type.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            region: input.region.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_google_chronicle(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_google_chronicle(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_logstash operation")]
    async fn gw_update_remote_access_session_logs_logstash(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsLogstashInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsLogstash {
            dns: input.dns.clone(),
            enable: input.enable.clone(),
            enable_tls: input.enable_tls.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            protocol: input.protocol.clone(),
            pull_interval: input.pull_interval.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_logstash(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_logstash(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_logz_io operation")]
    async fn gw_update_remote_access_session_logs_logz_io(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsLogzIoInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsLogzIo {
            enable: input.enable.clone(),
            json: input.json.clone(),
            logz_io_token: input.logz_io_token.clone(),
            output_format: input.output_format.clone(),
            protocol: input.protocol.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_logz_io(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_logz_io(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_splunk operation")]
    async fn gw_update_remote_access_session_logs_splunk(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsSplunkInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsSplunk {
            enable: input.enable.clone(),
            enable_batch: input.enable_batch.clone(),
            enable_tls: input.enable_tls.clone(),
            index: input.index.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            source: input.source.clone(),
            source_type: input.source_type.clone(),
            splunk_token: input.splunk_token.clone(),
            splunk_url: input.splunk_url.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_splunk(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_splunk(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_stdout operation")]
    async fn gw_update_remote_access_session_logs_stdout(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsStdoutInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsStdout {
            enable: input.enable.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_stdout(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_stdout(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_sumologic operation")]
    async fn gw_update_remote_access_session_logs_sumologic(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsSumologicInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsSumologic {
            enable: input.enable.clone(),
            endpoint: input.endpoint.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            sumologic_tags: input.sumologic_tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_sumologic(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_sumologic(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gw_update_remote_access_session_logs_syslog operation")]
    async fn gw_update_remote_access_session_logs_syslog(&self, Parameters(input): Parameters<GwUpdateRemoteAccessSessionLogsSyslogInput>) -> String {
        let req = crate::api::types::GwUpdateRemoteAccessSessionLogsSyslog {
            enable: input.enable.clone(),
            enable_tls: input.enable_tls.clone(),
            formatter: input.formatter.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            network: input.network.clone(),
            output_format: input.output_format.clone(),
            pull_interval: input.pull_interval.clone(),
            target_tag: input.target_tag.clone(),
            tls_certificate: input.tls_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gw_update_remote_access_session_logs_syslog(&req).await {
            Ok(result) => format::format_gw_update_remote_access_session_logs_syslog(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "gateway_update_tls_cert operation")]
    async fn gateway_update_tls_cert(&self, Parameters(input): Parameters<GatewayUpdateTlsCertInput>) -> String {
        let req = crate::api::types::GatewayUpdateTlsCert {
            cert_data: input.cert_data.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            json: input.json.clone(),
            key_data: input.key_data.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.gateway_update_tls_cert(&req).await {
            Ok(result) => format::format_gateway_update_tls_cert(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "generate_acme_eab operation")]
    async fn generate_acme_eab(&self, Parameters(input): Parameters<GenerateAcmeEabInput>) -> String {
        let req = crate::api::types::GenerateAcmeEab {
            cert_issuer_name: input.cert_issuer_name.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.generate_acme_eab(&req).await {
            Ok(result) => format::format_generate_acme_eab(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "generate_ca operation")]
    async fn generate_ca(&self, Parameters(input): Parameters<GenerateCaInput>) -> String {
        let req = crate::api::types::GenerateCa {
            alg: input.alg.clone(),
            allowed_domains: input.allowed_domains.clone(),
            delete_protection: input.delete_protection.clone(),
            extended_key_usage: input.extended_key_usage.clone(),
            json: input.json.clone(),
            key_type: input.key_type.clone(),
            max_path_len: input.max_path_len.clone(),
            pki_chain_name: input.pki_chain_name.clone(),
            protection_key_name: input.protection_key_name.clone(),
            split_level: input.split_level.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.generate_ca(&req).await {
            Ok(result) => format::format_generate_ca(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "generate_csr operation")]
    async fn generate_csr(&self, Parameters(input): Parameters<GenerateCsrInput>) -> String {
        let req = crate::api::types::GenerateCsr {
            alg: input.alg.clone(),
            alt_names: input.alt_names.clone(),
            certificate_type: input.certificate_type.clone(),
            city: input.city.clone(),
            common_name: input.common_name.clone(),
            country: input.country.clone(),
            critical: input.critical.clone(),
            dep: input.dep.clone(),
            email_addresses: input.email_addresses.clone(),
            export_private_key: input.export_private_key.clone(),
            generate_key: input.generate_key.clone(),
            hash_algorithm: input.hash_algorithm.clone(),
            ip_addresses: input.ip_addresses.clone(),
            json: input.json.clone(),
            key_type: input.key_type.clone(),
            name: input.name.clone(),
            org: input.org.clone(),
            split_level: input.split_level.clone(),
            state: input.state.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            uri_sans: input.uri_sans.clone(),
        };
        match self.client.generate_csr(&req).await {
            Ok(result) => format::format_generate_csr(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_account_logo operation")]
    async fn get_account_logo(&self, Parameters(_): Parameters<serde_json::Value>) -> String {
        match self.client.get_account_logo().await {
            Ok(result) => format::format_get_account_logo(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_account_settings operation")]
    async fn get_account_settings(&self, Parameters(input): Parameters<GetAccountSettingsInput>) -> String {
        let req = crate::api::types::GetAccountSettings {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_account_settings(&req).await {
            Ok(result) => format::format_get_account_settings(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_analytics_data operation")]
    async fn get_analytics_data(&self, Parameters(input): Parameters<GetAnalyticsDataInput>) -> String {
        let req = crate::api::types::GetAnalyticsData {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_analytics_data(&req).await {
            Ok(result) => format::format_get_analytics_data(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_auth_method operation")]
    async fn get_auth_method(&self, Parameters(input): Parameters<GetAuthMethodInput>) -> String {
        let req = crate::api::types::GetAuthMethod {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_auth_method(&req).await {
            Ok(result) => format::format_get_auth_method(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_cert_challenge operation")]
    async fn get_cert_challenge(&self, Parameters(input): Parameters<GetCertChallengeInput>) -> String {
        let req = crate::api::types::GetCertChallenge {
            access_id: input.access_id.clone(),
            cert_data: input.cert_data.clone(),
            json: input.json.clone(),
        };
        match self.client.get_cert_challenge(&req).await {
            Ok(result) => format::format_get_cert_challenge(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_certificate_value operation")]
    async fn get_certificate_value(&self, Parameters(input): Parameters<GetCertificateValueInput>) -> String {
        let req = crate::api::types::GetCertificateValue {
            cert_issuer_name: input.cert_issuer_name.clone(),
            display_id: input.display_id.clone(),
            ignore_cache: input.ignore_cache.clone(),
            issuance_token: input.issuance_token.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.get_certificate_value(&req).await {
            Ok(result) => format::format_get_certificate_value(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_dynamic_secret_value operation")]
    async fn get_dynamic_secret_value(&self, Parameters(input): Parameters<GetDynamicSecretValueInput>) -> String {
        let req = crate::api::types::GetDynamicSecretValue {
            args: input.args.clone(),
            dbname: input.dbname.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            target: input.target.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_dynamic_secret_value(&req).await {
            Ok(result) => format::format_get_dynamic_secret_value(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_event_forwarder operation")]
    async fn get_event_forwarder(&self, Parameters(input): Parameters<GetEventForwarderInput>) -> String {
        let req = crate::api::types::GetEventForwarder {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_event_forwarder(&req).await {
            Ok(result) => format::format_get_event_forwarder(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_group operation")]
    async fn get_group(&self, Parameters(input): Parameters<GetGroupInput>) -> String {
        let req = crate::api::types::GetGroup {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_group(&req).await {
            Ok(result) => format::format_get_group(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_kube_exec_creds operation")]
    async fn get_kube_exec_creds(&self, Parameters(input): Parameters<GetKubeExecCredsInput>) -> String {
        let req = crate::api::types::GetKubeExecCreds {
            alt_names: input.alt_names.clone(),
            api_version: input.api_version.clone(),
            cert_issuer_name: input.cert_issuer_name.clone(),
            common_name: input.common_name.clone(),
            csr_data_base64: input.csr_data_base64.clone(),
            extended_key_usage: input.extended_key_usage.clone(),
            extra_extensions: input.extra_extensions.clone(),
            json: input.json.clone(),
            key_data_base64: input.key_data_base64.clone(),
            max_path_len: input.max_path_len.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
            uri_sans: input.uri_sans.clone(),
        };
        match self.client.get_kube_exec_creds(&req).await {
            Ok(result) => format::format_get_kube_exec_creds(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_pki_certificate operation")]
    async fn get_pki_certificate(&self, Parameters(input): Parameters<GetPkiCertificateInput>) -> String {
        let req = crate::api::types::GetPkiCertificate {
            alt_names: input.alt_names.clone(),
            cert_issuer_name: input.cert_issuer_name.clone(),
            common_name: input.common_name.clone(),
            csr_data_base64: input.csr_data_base64.clone(),
            extended_key_usage: input.extended_key_usage.clone(),
            extra_extensions: input.extra_extensions.clone(),
            json: input.json.clone(),
            key_data_base64: input.key_data_base64.clone(),
            max_path_len: input.max_path_len.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
            uri_sans: input.uri_sans.clone(),
        };
        match self.client.get_pki_certificate(&req).await {
            Ok(result) => format::format_get_pki_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_role operation")]
    async fn get_role(&self, Parameters(input): Parameters<GetRoleInput>) -> String {
        let req = crate::api::types::GetRole {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_role(&req).await {
            Ok(result) => format::format_get_role(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_rotated_secret_value operation")]
    async fn get_rotated_secret_value(&self, Parameters(input): Parameters<GetRotatedSecretValueInput>) -> String {
        let req = crate::api::types::GetRotatedSecretValue {
            host: input.host.clone(),
            ignore_cache: input.ignore_cache.clone(),
            json: input.json.clone(),
            names: input.names.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.get_rotated_secret_value(&req).await {
            Ok(result) => format::format_get_rotated_secret_value(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_rsa_public operation")]
    async fn get_rsa_public(&self, Parameters(input): Parameters<GetRsaPublicInput>) -> String {
        let req = crate::api::types::GetRsaPublic {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_rsa_public(&req).await {
            Ok(result) => format::format_get_rsa_public(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_secret_value operation")]
    async fn get_secret_value(&self, Parameters(input): Parameters<GetSecretValueInput>) -> String {
        let req = crate::api::types::GetSecretValue {
            accessibility: input.accessibility.clone(),
            ignore_cache: input.ignore_cache.clone(),
            json: input.json.clone(),
            names: input.names.clone(),
            pretty_print: input.pretty_print.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.get_secret_value(&req).await {
            Ok(result) => format::format_get_secret_value(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_ssh_certificate operation")]
    async fn get_ssh_certificate(&self, Parameters(input): Parameters<GetSshCertificateInput>) -> String {
        let req = crate::api::types::GetSshCertificate {
            cert_issuer_name: input.cert_issuer_name.clone(),
            cert_username: input.cert_username.clone(),
            json: input.json.clone(),
            legacy_signing_alg_name: input.legacy_signing_alg_name.clone(),
            public_key_data: input.public_key_data.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_ssh_certificate(&req).await {
            Ok(result) => format::format_get_ssh_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_tags operation")]
    async fn get_tags(&self, Parameters(input): Parameters<GetTagsInput>) -> String {
        let req = crate::api::types::GetTags {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_tags(&req).await {
            Ok(result) => format::format_get_tags(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_target operation")]
    async fn get_target(&self, Parameters(input): Parameters<GetTargetInput>) -> String {
        let req = crate::api::types::GetTarget {
            json: input.json.clone(),
            name: input.name.clone(),
            show_versions: input.show_versions.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_target(&req).await {
            Ok(result) => format::format_get_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_target_details operation")]
    async fn get_target_details(&self, Parameters(input): Parameters<GetTargetDetailsInput>) -> String {
        let req = crate::api::types::GetTargetDetails {
            json: input.json.clone(),
            name: input.name.clone(),
            show_versions: input.show_versions.clone(),
            target_version: input.target_version.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_target_details(&req).await {
            Ok(result) => format::format_get_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "hmac operation")]
    async fn hmac(&self, Parameters(input): Parameters<HmacInput>) -> String {
        let req = crate::api::types::Hmac {
            display_id: input.display_id.clone(),
            hash_function: input.hash_function.clone(),
            input_format: input.input_format.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            plaintext: input.plaintext.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.hmac(&req).await {
            Ok(result) => format::format_hmac(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "import_passwords operation")]
    async fn import_passwords(&self, Parameters(input): Parameters<ImportPasswordsInput>) -> String {
        let req = crate::api::types::ImportPasswords {
            accessibility: input.accessibility.clone(),
            format: input.format.clone(),
            import_path: input.import_path.clone(),
            json: input.json.clone(),
            protection_key: input.protection_key.clone(),
            target_folder: input.target_folder.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_mode: input.update_mode.clone(),
        };
        match self.client.import_passwords(&req).await {
            Ok(result) => format::format_import_passwords(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_client_delete_rule operation")]
    async fn kmip_client_delete_rule(&self, Parameters(input): Parameters<KmipClientDeleteRuleInput>) -> String {
        let req = crate::api::types::KmipClientDeleteRule {
            client_id: input.client_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_client_delete_rule(&req).await {
            Ok(result) => format::format_kmip_client_delete_rule(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_client_set_rule operation")]
    async fn kmip_client_set_rule(&self, Parameters(input): Parameters<KmipClientSetRuleInput>) -> String {
        let req = crate::api::types::KmipClientSetRule {
            capability: input.capability.clone(),
            client_id: input.client_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_client_set_rule(&req).await {
            Ok(result) => format::format_kmip_client_set_rule(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_create_client operation")]
    async fn kmip_create_client(&self, Parameters(input): Parameters<KmipCreateClientInput>) -> String {
        let req = crate::api::types::KmipCreateClient {
            activate_keys_on_creation: input.activate_keys_on_creation.clone(),
            certificate_ttl: input.certificate_ttl.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_create_client(&req).await {
            Ok(result) => format::format_kmip_create_client(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_server_setup operation")]
    async fn kmip_server_setup(&self, Parameters(input): Parameters<KmipServerSetupInput>) -> String {
        let req = crate::api::types::KmipServerSetup {
            certificate_ttl: input.certificate_ttl.clone(),
            hostname: input.hostname.clone(),
            json: input.json.clone(),
            root: input.root.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_server_setup(&req).await {
            Ok(result) => format::format_kmip_server_setup(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_delete_client operation")]
    async fn kmip_delete_client(&self, Parameters(input): Parameters<KmipDeleteClientInput>) -> String {
        let req = crate::api::types::KmipDeleteClient {
            client_id: input.client_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_delete_client(&req).await {
            Ok(result) => format::format_kmip_delete_client(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_delete_server operation")]
    async fn kmip_delete_server(&self, Parameters(input): Parameters<KmipDeleteServerInput>) -> String {
        let req = crate::api::types::KmipDeleteServer {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_delete_server(&req).await {
            Ok(_) => format!("Success: DELETE /kmip-delete-environment"),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_describe_client operation")]
    async fn kmip_describe_client(&self, Parameters(input): Parameters<KmipDescribeClientInput>) -> String {
        let req = crate::api::types::KmipDescribeClient {
            client_id: input.client_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_describe_client(&req).await {
            Ok(result) => format::format_kmip_describe_client(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_describe_server operation")]
    async fn kmip_describe_server(&self, Parameters(input): Parameters<KmipDescribeServerInput>) -> String {
        let req = crate::api::types::KmipDescribeServer {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_describe_server(&req).await {
            Ok(result) => format::format_kmip_describe_server(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_list_clients operation")]
    async fn kmip_list_clients(&self, Parameters(input): Parameters<KmipListClientsInput>) -> String {
        let req = crate::api::types::KmipListClients {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_list_clients(&req).await {
            Ok(result) => format::format_kmip_list_clients(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_move_server operation")]
    async fn kmip_move_server(&self, Parameters(input): Parameters<KmipMoveServerInput>) -> String {
        let req = crate::api::types::KmipMoveServer {
            json: input.json.clone(),
            new_root: input.new_root.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_move_server(&req).await {
            Ok(result) => format::format_kmip_move_server(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_renew_client_certificate operation")]
    async fn kmip_renew_client_certificate(&self, Parameters(input): Parameters<KmipRenewClientCertificateInput>) -> String {
        let req = crate::api::types::KmipRenewClientCertificate {
            client_id: input.client_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_renew_client_certificate(&req).await {
            Ok(result) => format::format_kmip_renew_client_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_renew_server_certificate operation")]
    async fn kmip_renew_server_certificate(&self, Parameters(input): Parameters<KmipRenewServerCertificateInput>) -> String {
        let req = crate::api::types::KmipRenewServerCertificate {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_renew_server_certificate(&req).await {
            Ok(result) => format::format_kmip_renew_server_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kmip_set_server_state operation")]
    async fn kmip_set_server_state(&self, Parameters(input): Parameters<KmipSetServerStateInput>) -> String {
        let req = crate::api::types::KmipSetServerState {
            json: input.json.clone(),
            state: input.state.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.kmip_set_server_state(&req).await {
            Ok(result) => format::format_kmip_set_server_state(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "kubeconfig_generate operation")]
    async fn kubeconfig_generate(&self, Parameters(_): Parameters<serde_json::Value>) -> String {
        match self.client.kubeconfig_generate().await {
            Ok(result) => format::format_kubeconfig_generate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_acme_accounts operation")]
    async fn list_acme_accounts(&self, Parameters(input): Parameters<ListAcmeAccountsInput>) -> String {
        let req = crate::api::types::ListAcmeAccounts {
            cert_issuer_name: input.cert_issuer_name.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_acme_accounts(&req).await {
            Ok(result) => format::format_list_acme_accounts(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_auth_methods operation")]
    async fn list_auth_methods(&self, Parameters(input): Parameters<ListAuthMethodsInput>) -> String {
        let req = crate::api::types::ListAuthMethods {
            filter: input.filter.clone(),
            json: input.json.clone(),
            pagination_token: input.pagination_token.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_auth_methods(&req).await {
            Ok(result) => format::format_list_auth_methods(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_gateways operation")]
    async fn list_gateways(&self, Parameters(input): Parameters<ListGatewaysInput>) -> String {
        let req = crate::api::types::ListGateways {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_gateways(&req).await {
            Ok(result) => format::format_list_gateways(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_groups operation")]
    async fn list_groups(&self, Parameters(input): Parameters<ListGroupsInput>) -> String {
        let req = crate::api::types::ListGroups {
            filter: input.filter.clone(),
            json: input.json.clone(),
            pagination_token: input.pagination_token.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_groups(&req).await {
            Ok(result) => format::format_list_groups(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_items operation")]
    async fn list_items(&self, Parameters(input): Parameters<ListItemsInput>) -> String {
        let req = crate::api::types::ListItems {
            accessibility: input.accessibility.clone(),
            advanced_filter: input.advanced_filter.clone(),
            auto_pagination: input.auto_pagination.clone(),
            current_folder: input.current_folder.clone(),
            filter: input.filter.clone(),
            json: input.json.clone(),
            minimal_view: input.minimal_view.clone(),
            modified_after: input.modified_after.clone(),
            pagination_token: input.pagination_token.clone(),
            path: input.path.clone(),
            sra_only: input.sra_only.clone(),
            sub_types: input.sub_types.clone(),
            tag: input.tag.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_items(&req).await {
            Ok(result) => format::format_list_items(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_roles operation")]
    async fn list_roles(&self, Parameters(input): Parameters<ListRolesInput>) -> String {
        let req = crate::api::types::ListRoles {
            filter: input.filter.clone(),
            json: input.json.clone(),
            pagination_token: input.pagination_token.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_roles(&req).await {
            Ok(result) => format::format_list_roles(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_shared_items operation")]
    async fn list_shared_items(&self, Parameters(input): Parameters<ListSharedItemsInput>) -> String {
        let req = crate::api::types::ListSharedItems {
            accessibility: input.accessibility.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_shared_items(&req).await {
            Ok(result) => format::format_list_shared_items(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_sra_bastions operation")]
    async fn list_sra_bastions(&self, Parameters(input): Parameters<ListSraBastionsInput>) -> String {
        let req = crate::api::types::ListSraBastions {
            allowed_urls_only: input.allowed_urls_only.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_sra_bastions(&req).await {
            Ok(result) => format::format_list_sra_bastions(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_sra_sessions operation")]
    async fn list_sra_sessions(&self, Parameters(input): Parameters<ListSraSessionsInput>) -> String {
        let req = crate::api::types::ListSraSessions {
            json: input.json.clone(),
            resource_type: input.resource_type.clone(),
            status_type: input.status_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_sra_sessions(&req).await {
            Ok(result) => format::format_list_sra_sessions(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "list_targets operation")]
    async fn list_targets(&self, Parameters(input): Parameters<ListTargetsInput>) -> String {
        let req = crate::api::types::ListTargets {
            filter: input.filter.clone(),
            json: input.json.clone(),
            pagination_token: input.pagination_token.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.list_targets(&req).await {
            Ok(result) => format::format_list_targets(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "move_objects operation")]
    async fn move_objects(&self, Parameters(input): Parameters<MoveObjectsInput>) -> String {
        let req = crate::api::types::MoveObjects {
            json: input.json.clone(),
            objects_type: input.objects_type.clone(),
            source: input.source.clone(),
            target: input.target.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.move_objects(&req).await {
            Ok(result) => format::format_move_objects(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "policy_create_keys operation")]
    async fn policy_create_keys(&self, Parameters(input): Parameters<PolicyCreateKeysInput>) -> String {
        let req = crate::api::types::PolicyCreateKeys {
            allowed_algorithms: input.allowed_algorithms.clone(),
            allowed_key_names: input.allowed_key_names.clone(),
            allowed_key_types: input.allowed_key_types.clone(),
            json: input.json.clone(),
            max_rotation_interval_days: input.max_rotation_interval_days.clone(),
            object_types: input.object_types.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.policy_create_keys(&req).await {
            Ok(result) => format::format_policy_create_keys(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "policies_delete operation")]
    async fn policies_delete(&self, Parameters(input): Parameters<PoliciesDeleteInput>) -> String {
        let req = crate::api::types::PoliciesDelete {
            id: input.id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.policies_delete(&req).await {
            Ok(result) => format::format_policies_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "policies_get operation")]
    async fn policies_get(&self, Parameters(input): Parameters<PoliciesGetInput>) -> String {
        let req = crate::api::types::PoliciesGet {
            id: input.id.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.policies_get(&req).await {
            Ok(result) => format::format_policies_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "policies_list operation")]
    async fn policies_list(&self, Parameters(input): Parameters<PoliciesListInput>) -> String {
        let req = crate::api::types::PoliciesList {
            aggregate: input.aggregate.clone(),
            json: input.json.clone(),
            object_type: input.object_type.clone(),
            paths: input.paths.clone(),
            token: input.token.clone(),
            types: input.types.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.policies_list(&req).await {
            Ok(result) => format::format_policies_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "policy_update_keys operation")]
    async fn policy_update_keys(&self, Parameters(input): Parameters<PolicyUpdateKeysInput>) -> String {
        let req = crate::api::types::PolicyUpdateKeys {
            allowed_algorithms: input.allowed_algorithms.clone(),
            allowed_key_names: input.allowed_key_names.clone(),
            allowed_key_types: input.allowed_key_types.clone(),
            id: input.id.clone(),
            json: input.json.clone(),
            max_rotation_interval_days: input.max_rotation_interval_days.clone(),
            object_types: input.object_types.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.policy_update_keys(&req).await {
            Ok(result) => format::format_policy_update_keys(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "provision_certificate operation")]
    async fn provision_certificate(&self, Parameters(input): Parameters<ProvisionCertificateInput>) -> String {
        let req = crate::api::types::ProvisionCertificate {
            display_id: input.display_id.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.provision_certificate(&req).await {
            Ok(result) => format::format_provision_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "raw_creds operation")]
    async fn raw_creds(&self, Parameters(input): Parameters<RawCredsInput>) -> String {
        let req = crate::api::types::RawCreds {
            access_id: input.access_id.clone(),
            access_key: input.access_key.clone(),
        };
        match self.client.raw_creds(&req).await {
            Ok(result) => format::format_raw_creds(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "refresh_key operation")]
    async fn refresh_key(&self, Parameters(input): Parameters<RefreshKeyInput>) -> String {
        let req = crate::api::types::RefreshKey {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.refresh_key(&req).await {
            Ok(result) => format::format_refresh_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "renew_certificate operation")]
    async fn renew_certificate(&self, Parameters(input): Parameters<RenewCertificateInput>) -> String {
        let req = crate::api::types::RenewCertificate {
            cert_issuer_name: input.cert_issuer_name.clone(),
            generate_key: input.generate_key.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.renew_certificate(&req).await {
            Ok(result) => format::format_renew_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "request_access operation")]
    async fn request_access(&self, Parameters(input): Parameters<RequestAccessInput>) -> String {
        let req = crate::api::types::RequestAccess {
            capability: input.capability.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.request_access(&req).await {
            Ok(result) => format::format_request_access(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "reset_access_key operation")]
    async fn reset_access_key(&self, Parameters(input): Parameters<ResetAccessKeyInput>) -> String {
        let req = crate::api::types::ResetAccessKey {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.reset_access_key(&req).await {
            Ok(result) => format::format_reset_access_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "reverse_rbac operation")]
    async fn reverse_rbac(&self, Parameters(input): Parameters<ReverseRbacInput>) -> String {
        let req = crate::api::types::ReverseRbac {
            json: input.json.clone(),
            path: input.path.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.reverse_rbac(&req).await {
            Ok(result) => format::format_reverse_rbac(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "revoke_certificate operation")]
    async fn revoke_certificate(&self, Parameters(input): Parameters<RevokeCertificateInput>) -> String {
        let req = crate::api::types::RevokeCertificate {
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            serial_number: input.serial_number.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.revoke_certificate(&req).await {
            Ok(result) => format::format_revoke_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "revoke_creds operation")]
    async fn revoke_creds(&self, Parameters(_): Parameters<serde_json::Value>) -> String {
        match self.client.revoke_creds().await {
            Ok(result) => format::format_revoke_creds(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rollback_secret operation")]
    async fn rollback_secret(&self, Parameters(input): Parameters<RollbackSecretInput>) -> String {
        let req = crate::api::types::RollbackSecret {
            accessibility: input.accessibility.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            old_version: input.old_version.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rollback_secret(&req).await {
            Ok(result) => format::format_rollback_secret(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotate_key operation")]
    async fn rotate_key(&self, Parameters(input): Parameters<RotateKeyInput>) -> String {
        let req = crate::api::types::RotateKey {
            json: input.json.clone(),
            name: input.name.clone(),
            new_cert_pem_data: input.new_cert_pem_data.clone(),
            new_key_data: input.new_key_data.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotate_key(&req).await {
            Ok(result) => format::format_rotate_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotate_oidc_client_secret operation")]
    async fn rotate_oidc_client_secret(&self, Parameters(input): Parameters<RotateOidcClientSecretInput>) -> String {
        let req = crate::api::types::RotateOidcClientSecret {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotate_oidc_client_secret(&req).await {
            Ok(result) => format::format_rotate_oidc_client_secret(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_aws operation")]
    async fn rotated_secret_create_aws(&self, Parameters(input): Parameters<RotatedSecretCreateAwsInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateAws {
            api_id: input.api_id.clone(),
            api_key: input.api_key.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            aws_region: input.aws_region.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            grace_rotation: input.grace_rotation.clone(),
            grace_rotation_hour: input.grace_rotation_hour.clone(),
            grace_rotation_interval: input.grace_rotation_interval.clone(),
            grace_rotation_timing: input.grace_rotation_timing.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_aws(&req).await {
            Ok(result) => format::format_rotated_secret_create_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_azure operation")]
    async fn rotated_secret_create_azure(&self, Parameters(input): Parameters<RotatedSecretCreateAzureInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateAzure {
            api_id: input.api_id.clone(),
            api_key: input.api_key.clone(),
            application_id: input.application_id.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            explicitly_set_sa: input.explicitly_set_sa.clone(),
            grace_rotation: input.grace_rotation.clone(),
            grace_rotation_hour: input.grace_rotation_hour.clone(),
            grace_rotation_interval: input.grace_rotation_interval.clone(),
            grace_rotation_timing: input.grace_rotation_timing.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            resource_group_name: input.resource_group_name.clone(),
            resource_name: input.resource_name.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_disable_concurrent_connections: input.secure_access_disable_concurrent_connections.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            storage_account_key_name: input.storage_account_key_name.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.rotated_secret_create_azure(&req).await {
            Ok(result) => format::format_rotated_secret_create_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_cassandra operation")]
    async fn rotated_secret_create_cassandra(&self, Parameters(input): Parameters<RotatedSecretCreateCassandraInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateCassandra {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_cassandra(&req).await {
            Ok(result) => format::format_rotated_secret_create_cassandra(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_custom operation")]
    async fn rotated_secret_create_custom(&self, Parameters(input): Parameters<RotatedSecretCreateCustomInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateCustom {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            custom_payload: input.custom_payload.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_password_policy: input.enable_password_policy.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_ssh_user: input.secure_access_ssh_user.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            timeout_sec: input.timeout_sec.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_capital_letters: input.use_capital_letters.clone(),
            use_lower_letters: input.use_lower_letters.clone(),
            use_numbers: input.use_numbers.clone(),
            use_special_characters: input.use_special_characters.clone(),
        };
        match self.client.rotated_secret_create_custom(&req).await {
            Ok(result) => format::format_rotated_secret_create_custom(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_dockerhub operation")]
    async fn rotated_secret_create_dockerhub(&self, Parameters(input): Parameters<RotatedSecretCreateDockerhubInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateDockerhub {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_dockerhub(&req).await {
            Ok(result) => format::format_rotated_secret_create_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_gcp operation")]
    async fn rotated_secret_create_gcp(&self, Parameters(input): Parameters<RotatedSecretCreateGcpInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateGcp {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_service_account_email: input.gcp_service_account_email.clone(),
            gcp_service_account_key_id: input.gcp_service_account_key_id.clone(),
            grace_rotation: input.grace_rotation.clone(),
            grace_rotation_hour: input.grace_rotation_hour.clone(),
            grace_rotation_interval: input.grace_rotation_interval.clone(),
            grace_rotation_timing: input.grace_rotation_timing.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_gcp(&req).await {
            Ok(result) => format::format_rotated_secret_create_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_hanadb operation")]
    async fn rotated_secret_create_hanadb(&self, Parameters(input): Parameters<RotatedSecretCreateHanadbInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateHanadb {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_hanadb(&req).await {
            Ok(result) => format::format_rotated_secret_create_hanadb(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_ldap operation")]
    async fn rotated_secret_create_ldap(&self, Parameters(input): Parameters<RotatedSecretCreateLdapInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateLdap {
            provider_type: input.provider_type.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            tags: input.tags.clone(),
            target: input.target.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
        };
        match self.client.rotated_secret_create_ldap(&req).await {
            Ok(result) => format::format_rotated_secret_create_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_mongodb operation")]
    async fn rotated_secret_create_mongodb(&self, Parameters(input): Parameters<RotatedSecretCreateMongodbInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateMongodb {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_mongodb(&req).await {
            Ok(result) => format::format_rotated_secret_create_mongodb(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_mssql operation")]
    async fn rotated_secret_create_mssql(&self, Parameters(input): Parameters<RotatedSecretCreateMssqlInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateMssql {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_mssql(&req).await {
            Ok(result) => format::format_rotated_secret_create_mssql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_mysql operation")]
    async fn rotated_secret_create_mysql(&self, Parameters(input): Parameters<RotatedSecretCreateMysqlInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateMysql {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_mysql(&req).await {
            Ok(result) => format::format_rotated_secret_create_mysql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_open_ai operation")]
    async fn rotated_secret_create_open_ai(&self, Parameters(input): Parameters<RotatedSecretCreateOpenAiInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateOpenAi {
            api_key: input.api_key.clone(),
            api_key_id: input.api_key_id.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_open_ai(&req).await {
            Ok(result) => format::format_rotated_secret_create_open_ai(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_oracledb operation")]
    async fn rotated_secret_create_oracledb(&self, Parameters(input): Parameters<RotatedSecretCreateOracledbInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateOracledb {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_oracledb(&req).await {
            Ok(result) => format::format_rotated_secret_create_oracledb(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_postgresql operation")]
    async fn rotated_secret_create_postgresql(&self, Parameters(input): Parameters<RotatedSecretCreatePostgresqlInput>) -> String {
        let req = crate::api::types::RotatedSecretCreatePostgresql {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_postgresql(&req).await {
            Ok(result) => format::format_rotated_secret_create_postgresql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_redis operation")]
    async fn rotated_secret_create_redis(&self, Parameters(input): Parameters<RotatedSecretCreateRedisInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateRedis {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_redis(&req).await {
            Ok(result) => format::format_rotated_secret_create_redis(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_redshift operation")]
    async fn rotated_secret_create_redshift(&self, Parameters(input): Parameters<RotatedSecretCreateRedshiftInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateRedshift {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_redshift(&req).await {
            Ok(result) => format::format_rotated_secret_create_redshift(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_snowflake operation")]
    async fn rotated_secret_create_snowflake(&self, Parameters(input): Parameters<RotatedSecretCreateSnowflakeInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateSnowflake {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            private_key: input.private_key.clone(),
            private_key_file_name: input.private_key_file_name.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_snowflake(&req).await {
            Ok(result) => format::format_rotated_secret_create_snowflake(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_splunk operation")]
    async fn rotated_secret_create_splunk(&self, Parameters(input): Parameters<RotatedSecretCreateSplunkInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateSplunk {
            audience: input.audience.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_date: input.expiration_date.clone(),
            hec_token: input.hec_token.clone(),
            hec_token_name: input.hec_token_name.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            splunk_token: input.splunk_token.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            token_owner: input.token_owner.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_splunk(&req).await {
            Ok(result) => format::format_rotated_secret_create_splunk(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_ssh operation")]
    async fn rotated_secret_create_ssh(&self, Parameters(input): Parameters<RotatedSecretCreateSshInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateSsh {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            key_data_base64: input.key_data_base64.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            public_key_remote_path: input.public_key_remote_path.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_custom_cmd: input.rotator_custom_cmd.clone(),
            rotator_type: input.rotator_type.clone(),
            same_password: input.same_password.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_ssh_user: input.secure_access_ssh_user.clone(),
            secure_access_target_type: input.secure_access_target_type.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_ssh(&req).await {
            Ok(result) => format::format_rotated_secret_create_ssh(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_create_windows operation")]
    async fn rotated_secret_create_windows(&self, Parameters(input): Parameters<RotatedSecretCreateWindowsInput>) -> String {
        let req = crate::api::types::RotatedSecretCreateWindows {
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password_length: input.password_length.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            same_password: input.same_password.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            tags: input.tags.clone(),
            target_name: input.target_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_create_windows(&req).await {
            Ok(result) => format::format_rotated_secret_create_windows(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_delete operation")]
    async fn rotated_secret_delete(&self, Parameters(input): Parameters<RotatedSecretDeleteInput>) -> String {
        let req = crate::api::types::RotatedSecretDelete {
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.rotated_secret_delete(&req).await {
            Ok(result) => format::format_rotated_secret_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_delete_sync operation")]
    async fn rotated_secret_delete_sync(&self, Parameters(input): Parameters<RotatedSecretDeleteSyncInput>) -> String {
        let req = crate::api::types::RotatedSecretDeleteSync {
            delete_from_usc: input.delete_from_usc.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            remote_secret_name: input.remote_secret_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_name: input.usc_name.clone(),
        };
        match self.client.rotated_secret_delete_sync(&req).await {
            Ok(result) => format::format_rotated_secret_delete_sync(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_get_value operation")]
    async fn rotated_secret_get_value(&self, Parameters(input): Parameters<RotatedSecretGetValueInput>) -> String {
        let req = crate::api::types::RotatedSecretGetValue {
            host: input.host.clone(),
            ignore_cache: input.ignore_cache.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.rotated_secret_get_value(&req).await {
            Ok(result) => format::format_rotated_secret_get_value(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_list operation")]
    async fn rotated_secret_list(&self, Parameters(input): Parameters<RotatedSecretListInput>) -> String {
        let req = crate::api::types::RotatedSecretList {
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_list(&req).await {
            Ok(result) => format::format_rotated_secret_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_sync operation")]
    async fn rotated_secret_sync(&self, Parameters(input): Parameters<RotatedSecretSyncInput>) -> String {
        let req = crate::api::types::RotatedSecretSync {
            delete_remote: input.delete_remote.clone(),
            filter_secret_value: input.filter_secret_value.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            namespace: input.namespace.clone(),
            remote_secret_name: input.remote_secret_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_name: input.usc_name.clone(),
        };
        match self.client.rotated_secret_sync(&req).await {
            Ok(result) => format::format_rotated_secret_sync(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_aws operation")]
    async fn rotated_secret_update_aws(&self, Parameters(input): Parameters<RotatedSecretUpdateAwsInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateAws {
            add_tag: input.add_tag.clone(),
            api_id: input.api_id.clone(),
            api_key: input.api_key.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            aws_region: input.aws_region.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            grace_rotation: input.grace_rotation.clone(),
            grace_rotation_hour: input.grace_rotation_hour.clone(),
            grace_rotation_interval: input.grace_rotation_interval.clone(),
            grace_rotation_timing: input.grace_rotation_timing.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_aws(&req).await {
            Ok(result) => format::format_rotated_secret_update_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_azure operation")]
    async fn rotated_secret_update_azure(&self, Parameters(input): Parameters<RotatedSecretUpdateAzureInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateAzure {
            add_tag: input.add_tag.clone(),
            api_id: input.api_id.clone(),
            api_key: input.api_key.clone(),
            application_id: input.application_id.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            explicitly_set_sa: input.explicitly_set_sa.clone(),
            grace_rotation: input.grace_rotation.clone(),
            grace_rotation_hour: input.grace_rotation_hour.clone(),
            grace_rotation_interval: input.grace_rotation_interval.clone(),
            grace_rotation_timing: input.grace_rotation_timing.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            resource_group_name: input.resource_group_name.clone(),
            resource_name: input.resource_name.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_disable_concurrent_connections: input.secure_access_disable_concurrent_connections.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            storage_account_key_name: input.storage_account_key_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.rotated_secret_update_azure(&req).await {
            Ok(result) => format::format_rotated_secret_update_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_cassandra operation")]
    async fn rotated_secret_update_cassandra(&self, Parameters(input): Parameters<RotatedSecretUpdateCassandraInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateCassandra {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_cassandra(&req).await {
            Ok(result) => format::format_rotated_secret_update_cassandra(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_custom operation")]
    async fn rotated_secret_update_custom(&self, Parameters(input): Parameters<RotatedSecretUpdateCustomInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateCustom {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            custom_payload: input.custom_payload.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            enable_password_policy: input.enable_password_policy.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_ssh_user: input.secure_access_ssh_user.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            timeout_sec: input.timeout_sec.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_capital_letters: input.use_capital_letters.clone(),
            use_lower_letters: input.use_lower_letters.clone(),
            use_numbers: input.use_numbers.clone(),
            use_special_characters: input.use_special_characters.clone(),
        };
        match self.client.rotated_secret_update_custom(&req).await {
            Ok(result) => format::format_rotated_secret_update_custom(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_dockerhub operation")]
    async fn rotated_secret_update_dockerhub(&self, Parameters(input): Parameters<RotatedSecretUpdateDockerhubInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateDockerhub {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_dockerhub(&req).await {
            Ok(result) => format::format_rotated_secret_update_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_gcp operation")]
    async fn rotated_secret_update_gcp(&self, Parameters(input): Parameters<RotatedSecretUpdateGcpInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateGcp {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            gcp_service_account_email: input.gcp_service_account_email.clone(),
            gcp_service_account_key_id: input.gcp_service_account_key_id.clone(),
            grace_rotation: input.grace_rotation.clone(),
            grace_rotation_hour: input.grace_rotation_hour.clone(),
            grace_rotation_interval: input.grace_rotation_interval.clone(),
            grace_rotation_timing: input.grace_rotation_timing.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_gcp(&req).await {
            Ok(result) => format::format_rotated_secret_update_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_hanadb operation")]
    async fn rotated_secret_update_hanadb(&self, Parameters(input): Parameters<RotatedSecretUpdateHanadbInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateHanadb {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_hanadb(&req).await {
            Ok(result) => format::format_rotated_secret_update_hanadb(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_ldap operation")]
    async fn rotated_secret_update_ldap(&self, Parameters(input): Parameters<RotatedSecretUpdateLdapInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateLdap {
            provider_type: input.provider_type.clone(),
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            target: input.target.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
        };
        match self.client.rotated_secret_update_ldap(&req).await {
            Ok(result) => format::format_rotated_secret_update_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_mongodb operation")]
    async fn rotated_secret_update_mongodb(&self, Parameters(input): Parameters<RotatedSecretUpdateMongodbInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateMongodb {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_mongodb(&req).await {
            Ok(result) => format::format_rotated_secret_update_mongodb(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_mssql operation")]
    async fn rotated_secret_update_mssql(&self, Parameters(input): Parameters<RotatedSecretUpdateMssqlInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateMssql {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_mssql(&req).await {
            Ok(result) => format::format_rotated_secret_update_mssql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_mysql operation")]
    async fn rotated_secret_update_mysql(&self, Parameters(input): Parameters<RotatedSecretUpdateMysqlInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateMysql {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_mysql(&req).await {
            Ok(result) => format::format_rotated_secret_update_mysql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_open_ai operation")]
    async fn rotated_secret_update_open_ai(&self, Parameters(input): Parameters<RotatedSecretUpdateOpenAiInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateOpenAi {
            add_tag: input.add_tag.clone(),
            api_key: input.api_key.clone(),
            api_key_id: input.api_key_id.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_open_ai(&req).await {
            Ok(result) => format::format_rotated_secret_update_open_ai(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_oracledb operation")]
    async fn rotated_secret_update_oracledb(&self, Parameters(input): Parameters<RotatedSecretUpdateOracledbInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateOracledb {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_oracledb(&req).await {
            Ok(result) => format::format_rotated_secret_update_oracledb(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_postgresql operation")]
    async fn rotated_secret_update_postgresql(&self, Parameters(input): Parameters<RotatedSecretUpdatePostgresqlInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdatePostgresql {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_web: input.secure_access_web.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_postgresql(&req).await {
            Ok(result) => format::format_rotated_secret_update_postgresql(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_redis operation")]
    async fn rotated_secret_update_redis(&self, Parameters(input): Parameters<RotatedSecretUpdateRedisInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateRedis {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_redis(&req).await {
            Ok(result) => format::format_rotated_secret_update_redis(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_redshift operation")]
    async fn rotated_secret_update_redshift(&self, Parameters(input): Parameters<RotatedSecretUpdateRedshiftInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateRedshift {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_redshift(&req).await {
            Ok(result) => format::format_rotated_secret_update_redshift(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_snowflake operation")]
    async fn rotated_secret_update_snowflake(&self, Parameters(input): Parameters<RotatedSecretUpdateSnowflakeInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateSnowflake {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            private_key: input.private_key.clone(),
            private_key_file_name: input.private_key_file_name.clone(),
            rm_tag: input.rm_tag.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_snowflake(&req).await {
            Ok(result) => format::format_rotated_secret_update_snowflake(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_splunk operation")]
    async fn rotated_secret_update_splunk(&self, Parameters(input): Parameters<RotatedSecretUpdateSplunkInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateSplunk {
            add_tag: input.add_tag.clone(),
            audience: input.audience.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_date: input.expiration_date.clone(),
            hec_token: input.hec_token.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            splunk_token: input.splunk_token.clone(),
            token: input.token.clone(),
            token_owner: input.token_owner.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_splunk(&req).await {
            Ok(result) => format::format_rotated_secret_update_splunk(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_ssh operation")]
    async fn rotated_secret_update_ssh(&self, Parameters(input): Parameters<RotatedSecretUpdateSshInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateSsh {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            key_data_base64: input.key_data_base64.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            public_key_remote_path: input.public_key_remote_path.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_custom_cmd: input.rotator_custom_cmd.clone(),
            rotator_type: input.rotator_type.clone(),
            same_password: input.same_password.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_ssh_user: input.secure_access_ssh_user.clone(),
            secure_access_target_type: input.secure_access_target_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_ssh(&req).await {
            Ok(result) => format::format_rotated_secret_update_ssh(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "rotated_secret_update_windows operation")]
    async fn rotated_secret_update_windows(&self, Parameters(input): Parameters<RotatedSecretUpdateWindowsInput>) -> String {
        let req = crate::api::types::RotatedSecretUpdateWindows {
            add_tag: input.add_tag.clone(),
            authentication_credentials: input.authentication_credentials.clone(),
            auto_rotate: input.auto_rotate.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password_length: input.password_length.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_type: input.rotator_type.clone(),
            same_password: input.same_password.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.rotated_secret_update_windows(&req).await {
            Ok(result) => format::format_rotated_secret_update_windows(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "set_item_state operation")]
    async fn set_item_state(&self, Parameters(input): Parameters<SetItemStateInput>) -> String {
        let req = crate::api::types::SetItemState {
            desired_state: input.desired_state.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.set_item_state(&req).await {
            Ok(result) => format::format_set_item_state(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "set_role_rule operation")]
    async fn set_role_rule(&self, Parameters(input): Parameters<SetRoleRuleInput>) -> String {
        let req = crate::api::types::SetRoleRule {
            capability: input.capability.clone(),
            json: input.json.clone(),
            path: input.path.clone(),
            role_name: input.role_name.clone(),
            rule_type: input.rule_type.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.set_role_rule(&req).await {
            Ok(result) => format::format_set_role_rule(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "share_item operation")]
    async fn share_item(&self, Parameters(input): Parameters<ShareItemInput>) -> String {
        let req = crate::api::types::ShareItem {
            accessibility: input.accessibility.clone(),
            action: input.action.clone(),
            emails: input.emails.clone(),
            item_name: input.item_name.clone(),
            json: input.json.clone(),
            share_type: input.share_type.clone(),
            shared_token_id: input.shared_token_id.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
            view_once: input.view_once.clone(),
        };
        match self.client.share_item(&req).await {
            Ok(result) => format::format_share_item(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "sign_data_with_classic_key operation")]
    async fn sign_data_with_classic_key(&self, Parameters(input): Parameters<SignDataWithClassicKeyInput>) -> String {
        let req = crate::api::types::SignDataWithClassicKey {
            data: input.data.clone(),
            display_id: input.display_id.clone(),
            hashed: input.hashed.clone(),
            hashing_method: input.hashing_method.clone(),
            ignore_cache: input.ignore_cache.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.sign_data_with_classic_key(&req).await {
            Ok(result) => format::format_sign_data_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "sign_ec_dsa operation")]
    async fn sign_ec_dsa(&self, Parameters(input): Parameters<SignEcDsaInput>) -> String {
        let req = crate::api::types::SignEcDsa {
            accessibility: input.accessibility.clone(),
            display_id: input.display_id.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            message: input.message.clone(),
            prehashed: input.prehashed.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.sign_ec_dsa(&req).await {
            Ok(result) => format::format_sign_ec_dsa(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "sign_gpg operation")]
    async fn sign_gpg(&self, Parameters(input): Parameters<SignGpgInput>) -> String {
        let req = crate::api::types::SignGpg {
            display_id: input.display_id.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            message: input.message.clone(),
            passphrase: input.passphrase.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.sign_gpg(&req).await {
            Ok(result) => format::format_sign_gpg(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "sign_jwt_with_classic_key operation")]
    async fn sign_jwt_with_classic_key(&self, Parameters(input): Parameters<SignJwtWithClassicKeyInput>) -> String {
        let req = crate::api::types::SignJwtWithClassicKey {
            display_id: input.display_id.clone(),
            json: input.json.clone(),
            jwt_claims: input.jwt_claims.clone(),
            signing_method: input.signing_method.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.sign_jwt_with_classic_key(&req).await {
            Ok(result) => format::format_sign_jwt_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "sign_pkcs1 operation")]
    async fn sign_pkcs1(&self, Parameters(input): Parameters<SignPkcs1Input>) -> String {
        let req = crate::api::types::SignPkcs1 {
            display_id: input.display_id.clone(),
            hash_function: input.hash_function.clone(),
            input_format: input.input_format.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            message: input.message.clone(),
            prehashed: input.prehashed.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.sign_pkcs1(&req).await {
            Ok(result) => format::format_sign_pkcs1(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "sign_pki_cert_with_classic_key operation")]
    async fn sign_pki_cert_with_classic_key(&self, Parameters(input): Parameters<SignPkiCertWithClassicKeyInput>) -> String {
        let req = crate::api::types::SignPkiCertWithClassicKey {
            common_name: input.common_name.clone(),
            country: input.country.clone(),
            display_id: input.display_id.clone(),
            dns_names: input.dns_names.clone(),
            json: input.json.clone(),
            key_usage: input.key_usage.clone(),
            locality: input.locality.clone(),
            organizational_units: input.organizational_units.clone(),
            organizations: input.organizations.clone(),
            postal_code: input.postal_code.clone(),
            province: input.province.clone(),
            public_key_pem_data: input.public_key_pem_data.clone(),
            signing_method: input.signing_method.clone(),
            street_address: input.street_address.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
            uri_sans: input.uri_sans.clone(),
            version: input.version.clone(),
        };
        match self.client.sign_pki_cert_with_classic_key(&req).await {
            Ok(result) => format::format_sign_pki_cert_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "sign_rsa_ssa_pss operation")]
    async fn sign_rsa_ssa_pss(&self, Parameters(input): Parameters<SignRsaSsaPssInput>) -> String {
        let req = crate::api::types::SignRsaSsaPss {
            display_id: input.display_id.clone(),
            hash_function: input.hash_function.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            message: input.message.clone(),
            prehashed: input.prehashed.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.sign_rsa_ssa_pss(&req).await {
            Ok(result) => format::format_sign_rsa_ssa_pss(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "static_creds_auth operation")]
    async fn static_creds_auth(&self, Parameters(input): Parameters<StaticCredsAuthInput>) -> String {
        let req = crate::api::types::StaticCredsAuth {
            access_id: input.access_id.clone(),
            admin_email: input.admin_email.clone(),
            creds: input.creds.clone(),
            json: input.json.clone(),
        };
        match self.client.static_creds_auth(&req).await {
            Ok(result) => format::format_static_creds_auth(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "static_secret_delete_sync operation")]
    async fn static_secret_delete_sync(&self, Parameters(input): Parameters<StaticSecretDeleteSyncInput>) -> String {
        let req = crate::api::types::StaticSecretDeleteSync {
            delete_from_usc: input.delete_from_usc.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            remote_secret_name: input.remote_secret_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_name: input.usc_name.clone(),
        };
        match self.client.static_secret_delete_sync(&req).await {
            Ok(result) => format::format_static_secret_delete_sync(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "static_secret_sync operation")]
    async fn static_secret_sync(&self, Parameters(input): Parameters<StaticSecretSyncInput>) -> String {
        let req = crate::api::types::StaticSecretSync {
            delete_remote: input.delete_remote.clone(),
            filter_secret_value: input.filter_secret_value.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            namespace: input.namespace.clone(),
            remote_secret_name: input.remote_secret_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_name: input.usc_name.clone(),
        };
        match self.client.static_secret_sync(&req).await {
            Ok(result) => format::format_static_secret_sync(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_artifactory operation")]
    async fn target_create_artifactory(&self, Parameters(input): Parameters<TargetCreateArtifactoryInput>) -> String {
        let req = crate::api::types::TargetCreateArtifactory {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            base_url: input.base_url.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_artifactory(&req).await {
            Ok(result) => format::format_target_create_artifactory(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_aws operation")]
    async fn target_create_aws(&self, Parameters(input): Parameters<TargetCreateAwsInput>) -> String {
        let req = crate::api::types::TargetCreateAws {
            access_key: input.access_key.clone(),
            access_key_id: input.access_key_id.clone(),
            description: input.description.clone(),
            generate_external_id: input.generate_external_id.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            region: input.region.clone(),
            role_arn: input.role_arn.clone(),
            session_token: input.session_token.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_create_aws(&req).await {
            Ok(result) => format::format_target_create_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_azure operation")]
    async fn target_create_azure(&self, Parameters(input): Parameters<TargetCreateAzureInput>) -> String {
        let req = crate::api::types::TargetCreateAzure {
            azure_cloud: input.azure_cloud.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            resource_group_name: input.resource_group_name.clone(),
            resource_name: input.resource_name.clone(),
            subscription_id: input.subscription_id.clone(),
            tenant_id: input.tenant_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_create_azure(&req).await {
            Ok(result) => format::format_target_create_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_db operation")]
    async fn target_create_db(&self, Parameters(input): Parameters<TargetCreateDbInput>) -> String {
        let req = crate::api::types::TargetCreateDb {
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            cloud_service_provider: input.cloud_service_provider.clone(),
            cluster_mode: input.cluster_mode.clone(),
            comment: input.comment.clone(),
            connection_type: input.connection_type.clone(),
            db_name: input.db_name.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            db_type: input.db_type.clone(),
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mongodb_atlas: input.mongodb_atlas.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            name: input.name.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_wallet_login_type: input.oracle_wallet_login_type.clone(),
            oracle_wallet_p12_file_data: input.oracle_wallet_p12_file_data.clone(),
            oracle_wallet_sso_file_data: input.oracle_wallet_sso_file_data.clone(),
            parent_target_name: input.parent_target_name.clone(),
            port: input.port.clone(),
            pwd: input.pwd.clone(),
            snowflake_account: input.snowflake_account.clone(),
            snowflake_api_private_key: input.snowflake_api_private_key.clone(),
            snowflake_api_private_key_password: input.snowflake_api_private_key_password.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_name: input.user_name.clone(),
        };
        match self.client.target_create_db(&req).await {
            Ok(result) => format::format_target_create_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_dockerhub operation")]
    async fn target_create_dockerhub(&self, Parameters(input): Parameters<TargetCreateDockerhubInput>) -> String {
        let req = crate::api::types::TargetCreateDockerhub {
            description: input.description.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_dockerhub(&req).await {
            Ok(result) => format::format_target_create_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_eks operation")]
    async fn target_create_eks(&self, Parameters(input): Parameters<TargetCreateEksInput>) -> String {
        let req = crate::api::types::TargetCreateEks {
            description: input.description.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_create_eks(&req).await {
            Ok(result) => format::format_target_create_eks(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_gcp operation")]
    async fn target_create_gcp(&self, Parameters(input): Parameters<TargetCreateGcpInput>) -> String {
        let req = crate::api::types::TargetCreateGcp {
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_create_gcp(&req).await {
            Ok(result) => format::format_target_create_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_gemini operation")]
    async fn target_create_gemini(&self, Parameters(input): Parameters<TargetCreateGeminiInput>) -> String {
        let req = crate::api::types::TargetCreateGemini {
            api_key: input.api_key.clone(),
            description: input.description.clone(),
            gemini_url: input.gemini_url.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_gemini(&req).await {
            Ok(result) => format::format_target_create_gemini(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_github operation")]
    async fn target_create_github(&self, Parameters(input): Parameters<TargetCreateGithubInput>) -> String {
        let req = crate::api::types::TargetCreateGithub {
            description: input.description.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_github(&req).await {
            Ok(result) => format::format_target_create_github(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_gitlab operation")]
    async fn target_create_gitlab(&self, Parameters(input): Parameters<TargetCreateGitlabInput>) -> String {
        let req = crate::api::types::TargetCreateGitlab {
            description: input.description.clone(),
            gitlab_access_token: input.gitlab_access_token.clone(),
            gitlab_certificate: input.gitlab_certificate.clone(),
            gitlab_url: input.gitlab_url.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_gitlab(&req).await {
            Ok(result) => format::format_target_create_gitlab(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_gke operation")]
    async fn target_create_gke(&self, Parameters(input): Parameters<TargetCreateGkeInput>) -> String {
        let req = crate::api::types::TargetCreateGke {
            description: input.description.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_create_gke(&req).await {
            Ok(result) => format::format_target_create_gke(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_global_sign operation")]
    async fn target_create_global_sign(&self, Parameters(input): Parameters<TargetCreateGlobalSignInput>) -> String {
        let req = crate::api::types::TargetCreateGlobalSign {
            contact_email: input.contact_email.clone(),
            contact_first_name: input.contact_first_name.clone(),
            contact_last_name: input.contact_last_name.clone(),
            contact_phone: input.contact_phone.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            profile_id: input.profile_id.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.target_create_global_sign(&req).await {
            Ok(result) => format::format_target_create_global_sign(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_global_sign_atlas operation")]
    async fn target_create_global_sign_atlas(&self, Parameters(input): Parameters<TargetCreateGlobalSignAtlasInput>) -> String {
        let req = crate::api::types::TargetCreateGlobalSignAtlas {
            api_key: input.api_key.clone(),
            api_secret: input.api_secret.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mtls_cert_data_base64: input.mtls_cert_data_base64.clone(),
            mtls_key_data_base64: input.mtls_key_data_base64.clone(),
            name: input.name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_global_sign_atlas(&req).await {
            Ok(result) => format::format_target_create_global_sign_atlas(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_godaddy operation")]
    async fn target_create_godaddy(&self, Parameters(input): Parameters<TargetCreateGodaddyInput>) -> String {
        let req = crate::api::types::TargetCreateGodaddy {
            api_key: input.api_key.clone(),
            customer_id: input.customer_id.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            secret: input.secret.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_godaddy(&req).await {
            Ok(result) => format::format_target_create_godaddy(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_hashi_vault operation")]
    async fn target_create_hashi_vault(&self, Parameters(input): Parameters<TargetCreateHashiVaultInput>) -> String {
        let req = crate::api::types::TargetCreateHashiVault {
            description: input.description.clone(),
            hashi_url: input.hashi_url.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            namespace: input.namespace.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            vault_token: input.vault_token.clone(),
        };
        match self.client.target_create_hashi_vault(&req).await {
            Ok(result) => format::format_target_create_hashi_vault(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_k8s operation")]
    async fn target_create_k8s(&self, Parameters(input): Parameters<TargetCreateK8sInput>) -> String {
        let req = crate::api::types::TargetCreateK8s {
            description: input.description.clone(),
            json: input.json.clone(),
            k8s_auth_type: input.k8s_auth_type.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
        };
        match self.client.target_create_k8s(&req).await {
            Ok(result) => format::format_target_create_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_ldap operation")]
    async fn target_create_ldap(&self, Parameters(input): Parameters<TargetCreateLdapInput>) -> String {
        let req = crate::api::types::TargetCreateLdap {
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            server_type: input.server_type.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_ldap(&req).await {
            Ok(result) => format::format_target_create_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_lets_encrypt operation")]
    async fn target_create_lets_encrypt(&self, Parameters(input): Parameters<TargetCreateLetsEncryptInput>) -> String {
        let req = crate::api::types::TargetCreateLetsEncrypt {
            acme_challenge: input.acme_challenge.clone(),
            description: input.description.clone(),
            dns_target_creds: input.dns_target_creds.clone(),
            email: input.email.clone(),
            gcp_project: input.gcp_project.clone(),
            hosted_zone: input.hosted_zone.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            lets_encrypt_url: input.lets_encrypt_url.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            resource_group: input.resource_group.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_lets_encrypt(&req).await {
            Ok(result) => format::format_target_create_lets_encrypt(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_linked operation")]
    async fn target_create_linked(&self, Parameters(input): Parameters<TargetCreateLinkedInput>) -> String {
        let req = crate::api::types::TargetCreateLinked {
            description: input.description.clone(),
            hosts: input.hosts.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_linked(&req).await {
            Ok(result) => format::format_target_create_linked(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_open_ai operation")]
    async fn target_create_open_ai(&self, Parameters(input): Parameters<TargetCreateOpenAiInput>) -> String {
        let req = crate::api::types::TargetCreateOpenAi {
            api_key: input.api_key.clone(),
            api_key_id: input.api_key_id.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            model: input.model.clone(),
            name: input.name.clone(),
            openai_url: input.openai_url.clone(),
            organization_id: input.organization_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_open_ai(&req).await {
            Ok(result) => format::format_target_create_open_ai(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_ping operation")]
    async fn target_create_ping(&self, Parameters(input): Parameters<TargetCreatePingInput>) -> String {
        let req = crate::api::types::TargetCreatePing {
            administrative_port: input.administrative_port.clone(),
            authorization_port: input.authorization_port.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            ping_url: input.ping_url.clone(),
            privileged_user: input.privileged_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_ping(&req).await {
            Ok(result) => format::format_target_create_ping(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_rabbit_mq operation")]
    async fn target_create_rabbit_mq(&self, Parameters(input): Parameters<TargetCreateRabbitMqInput>) -> String {
        let req = crate::api::types::TargetCreateRabbitMq {
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            rabbitmq_server_password: input.rabbitmq_server_password.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_server_user: input.rabbitmq_server_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_rabbit_mq(&req).await {
            Ok(result) => format::format_target_create_rabbit_mq(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_salesforce operation")]
    async fn target_create_salesforce(&self, Parameters(input): Parameters<TargetCreateSalesforceInput>) -> String {
        let req = crate::api::types::TargetCreateSalesforce {
            app_private_key_data: input.app_private_key_data.clone(),
            auth_flow: input.auth_flow.clone(),
            ca_cert_data: input.ca_cert_data.clone(),
            ca_cert_name: input.ca_cert_name.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            description: input.description.clone(),
            email: input.email.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            security_token: input.security_token.clone(),
            tenant_url: input.tenant_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_salesforce(&req).await {
            Ok(result) => format::format_target_create_salesforce(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_sectigo operation")]
    async fn target_create_sectigo(&self, Parameters(input): Parameters<TargetCreateSectigoInput>) -> String {
        let req = crate::api::types::TargetCreateSectigo {
            certificate_profile_id: input.certificate_profile_id.clone(),
            customer_uri: input.customer_uri.clone(),
            description: input.description.clone(),
            external_requester: input.external_requester.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            organization_id: input.organization_id.clone(),
            password: input.password.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.target_create_sectigo(&req).await {
            Ok(result) => format::format_target_create_sectigo(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_splunk operation")]
    async fn target_create_splunk(&self, Parameters(input): Parameters<TargetCreateSplunkInput>) -> String {
        let req = crate::api::types::TargetCreateSplunk {
            audience: input.audience.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            password: input.password.clone(),
            token: input.token.clone(),
            token_owner: input.token_owner.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
            use_tls: input.use_tls.clone(),
            username: input.username.clone(),
        };
        match self.client.target_create_splunk(&req).await {
            Ok(result) => format::format_target_create_splunk(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_ssh operation")]
    async fn target_create_ssh(&self, Parameters(input): Parameters<TargetCreateSshInput>) -> String {
        let req = crate::api::types::TargetCreateSsh {
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            port: input.port.clone(),
            private_key: input.private_key.clone(),
            private_key_password: input.private_key_password.clone(),
            ssh_password: input.ssh_password.clone(),
            ssh_username: input.ssh_username.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_ssh(&req).await {
            Ok(result) => format::format_target_create_ssh(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_web operation")]
    async fn target_create_web(&self, Parameters(input): Parameters<TargetCreateWebInput>) -> String {
        let req = crate::api::types::TargetCreateWeb {
            description: input.description.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.target_create_web(&req).await {
            Ok(result) => format::format_target_create_web(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_windows operation")]
    async fn target_create_windows(&self, Parameters(input): Parameters<TargetCreateWindowsInput>) -> String {
        let req = crate::api::types::TargetCreateWindows {
            certificate: input.certificate.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            domain: input.domain.clone(),
            hostname: input.hostname.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            password: input.password.clone(),
            port: input.port.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_tls: input.use_tls.clone(),
            username: input.username.clone(),
        };
        match self.client.target_create_windows(&req).await {
            Ok(result) => format::format_target_create_windows(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_create_zero_ssl operation")]
    async fn target_create_zero_ssl(&self, Parameters(input): Parameters<TargetCreateZeroSslInput>) -> String {
        let req = crate::api::types::TargetCreateZeroSsl {
            api_key: input.api_key.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_target_email: input.imap_target_email.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_create_zero_ssl(&req).await {
            Ok(result) => format::format_target_create_zero_ssl(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_delete operation")]
    async fn target_delete(&self, Parameters(input): Parameters<TargetDeleteInput>) -> String {
        let req = crate::api::types::TargetDelete {
            force_deletion: input.force_deletion.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            target_version: input.target_version.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_delete(&req).await {
            Ok(result) => format::format_target_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_get operation")]
    async fn target_get(&self, Parameters(input): Parameters<TargetGetInput>) -> String {
        let req = crate::api::types::TargetGet {
            json: input.json.clone(),
            name: input.name.clone(),
            show_versions: input.show_versions.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_get(&req).await {
            Ok(result) => format::format_target_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_get_details operation")]
    async fn target_get_details(&self, Parameters(input): Parameters<TargetGetDetailsInput>) -> String {
        let req = crate::api::types::TargetGetDetails {
            json: input.json.clone(),
            name: input.name.clone(),
            show_versions: input.show_versions.clone(),
            target_version: input.target_version.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_get_details(&req).await {
            Ok(result) => format::format_target_get_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_list operation")]
    async fn target_list(&self, Parameters(input): Parameters<TargetListInput>) -> String {
        let req = crate::api::types::TargetList {
            filter: input.filter.clone(),
            json: input.json.clone(),
            pagination_token: input.pagination_token.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_list(&req).await {
            Ok(result) => format::format_target_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_artifactory operation")]
    async fn target_update_artifactory(&self, Parameters(input): Parameters<TargetUpdateArtifactoryInput>) -> String {
        let req = crate::api::types::TargetUpdateArtifactory {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            base_url: input.base_url.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_artifactory(&req).await {
            Ok(result) => format::format_target_update_artifactory(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_aws operation")]
    async fn target_update_aws(&self, Parameters(input): Parameters<TargetUpdateAwsInput>) -> String {
        let req = crate::api::types::TargetUpdateAws {
            access_key: input.access_key.clone(),
            access_key_id: input.access_key_id.clone(),
            description: input.description.clone(),
            generate_external_id: input.generate_external_id.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            region: input.region.clone(),
            role_arn: input.role_arn.clone(),
            session_token: input.session_token.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_update_aws(&req).await {
            Ok(result) => format::format_target_update_aws(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_azure operation")]
    async fn target_update_azure(&self, Parameters(input): Parameters<TargetUpdateAzureInput>) -> String {
        let req = crate::api::types::TargetUpdateAzure {
            azure_cloud: input.azure_cloud.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            resource_group_name: input.resource_group_name.clone(),
            resource_name: input.resource_name.clone(),
            subscription_id: input.subscription_id.clone(),
            tenant_id: input.tenant_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_update_azure(&req).await {
            Ok(result) => format::format_target_update_azure(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_db operation")]
    async fn target_update_db(&self, Parameters(input): Parameters<TargetUpdateDbInput>) -> String {
        let req = crate::api::types::TargetUpdateDb {
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            cloud_service_provider: input.cloud_service_provider.clone(),
            cluster_mode: input.cluster_mode.clone(),
            comment: input.comment.clone(),
            connection_type: input.connection_type.clone(),
            db_name: input.db_name.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            db_type: input.db_type.clone(),
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mongodb_atlas: input.mongodb_atlas.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_wallet_login_type: input.oracle_wallet_login_type.clone(),
            oracle_wallet_p12_file_data: input.oracle_wallet_p12_file_data.clone(),
            oracle_wallet_sso_file_data: input.oracle_wallet_sso_file_data.clone(),
            parent_target_name: input.parent_target_name.clone(),
            port: input.port.clone(),
            pwd: input.pwd.clone(),
            snowflake_account: input.snowflake_account.clone(),
            snowflake_api_private_key: input.snowflake_api_private_key.clone(),
            snowflake_api_private_key_password: input.snowflake_api_private_key_password.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_name: input.user_name.clone(),
        };
        match self.client.target_update_db(&req).await {
            Ok(result) => format::format_target_update_db(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_dockerhub operation")]
    async fn target_update_dockerhub(&self, Parameters(input): Parameters<TargetUpdateDockerhubInput>) -> String {
        let req = crate::api::types::TargetUpdateDockerhub {
            description: input.description.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_dockerhub(&req).await {
            Ok(result) => format::format_target_update_dockerhub(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_eks operation")]
    async fn target_update_eks(&self, Parameters(input): Parameters<TargetUpdateEksInput>) -> String {
        let req = crate::api::types::TargetUpdateEks {
            description: input.description.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_update_eks(&req).await {
            Ok(result) => format::format_target_update_eks(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_gcp operation")]
    async fn target_update_gcp(&self, Parameters(input): Parameters<TargetUpdateGcpInput>) -> String {
        let req = crate::api::types::TargetUpdateGcp {
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_update_gcp(&req).await {
            Ok(result) => format::format_target_update_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_gemini operation")]
    async fn target_update_gemini(&self, Parameters(input): Parameters<TargetUpdateGeminiInput>) -> String {
        let req = crate::api::types::TargetUpdateGemini {
            api_key: input.api_key.clone(),
            description: input.description.clone(),
            gemini_url: input.gemini_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_comment: input.new_comment.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_gemini(&req).await {
            Ok(result) => format::format_target_update_gemini(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_github operation")]
    async fn target_update_github(&self, Parameters(input): Parameters<TargetUpdateGithubInput>) -> String {
        let req = crate::api::types::TargetUpdateGithub {
            description: input.description.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_github(&req).await {
            Ok(result) => format::format_target_update_github(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_gitlab operation")]
    async fn target_update_gitlab(&self, Parameters(input): Parameters<TargetUpdateGitlabInput>) -> String {
        let req = crate::api::types::TargetUpdateGitlab {
            description: input.description.clone(),
            gitlab_access_token: input.gitlab_access_token.clone(),
            gitlab_certificate: input.gitlab_certificate.clone(),
            gitlab_url: input.gitlab_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_gitlab(&req).await {
            Ok(result) => format::format_target_update_gitlab(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_gke operation")]
    async fn target_update_gke(&self, Parameters(input): Parameters<TargetUpdateGkeInput>) -> String {
        let req = crate::api::types::TargetUpdateGke {
            description: input.description.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.target_update_gke(&req).await {
            Ok(result) => format::format_target_update_gke(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_global_sign operation")]
    async fn target_update_global_sign(&self, Parameters(input): Parameters<TargetUpdateGlobalSignInput>) -> String {
        let req = crate::api::types::TargetUpdateGlobalSign {
            contact_email: input.contact_email.clone(),
            contact_first_name: input.contact_first_name.clone(),
            contact_last_name: input.contact_last_name.clone(),
            contact_phone: input.contact_phone.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            profile_id: input.profile_id.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.target_update_global_sign(&req).await {
            Ok(result) => format::format_target_update_global_sign(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_global_sign_atlas operation")]
    async fn target_update_global_sign_atlas(&self, Parameters(input): Parameters<TargetUpdateGlobalSignAtlasInput>) -> String {
        let req = crate::api::types::TargetUpdateGlobalSignAtlas {
            api_key: input.api_key.clone(),
            api_secret: input.api_secret.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mtls_cert_data_base64: input.mtls_cert_data_base64.clone(),
            mtls_key_data_base64: input.mtls_key_data_base64.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_global_sign_atlas(&req).await {
            Ok(result) => format::format_target_update_global_sign_atlas(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_godaddy operation")]
    async fn target_update_godaddy(&self, Parameters(input): Parameters<TargetUpdateGodaddyInput>) -> String {
        let req = crate::api::types::TargetUpdateGodaddy {
            api_key: input.api_key.clone(),
            customer_id: input.customer_id.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            secret: input.secret.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_godaddy(&req).await {
            Ok(result) => format::format_target_update_godaddy(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_hashi_vault operation")]
    async fn target_update_hashi_vault(&self, Parameters(input): Parameters<TargetUpdateHashiVaultInput>) -> String {
        let req = crate::api::types::TargetUpdateHashiVault {
            description: input.description.clone(),
            hashi_url: input.hashi_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            namespace: input.namespace.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            vault_token: input.vault_token.clone(),
        };
        match self.client.target_update_hashi_vault(&req).await {
            Ok(result) => format::format_target_update_hashi_vault(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_k8s operation")]
    async fn target_update_k8s(&self, Parameters(input): Parameters<TargetUpdateK8sInput>) -> String {
        let req = crate::api::types::TargetUpdateK8s {
            description: input.description.clone(),
            json: input.json.clone(),
            k8s_auth_type: input.k8s_auth_type.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
        };
        match self.client.target_update_k8s(&req).await {
            Ok(result) => format::format_target_update_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_ldap operation")]
    async fn target_update_ldap(&self, Parameters(input): Parameters<TargetUpdateLdapInput>) -> String {
        let req = crate::api::types::TargetUpdateLdap {
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            server_type: input.server_type.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_ldap(&req).await {
            Ok(result) => format::format_target_update_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_lets_encrypt operation")]
    async fn target_update_lets_encrypt(&self, Parameters(input): Parameters<TargetUpdateLetsEncryptInput>) -> String {
        let req = crate::api::types::TargetUpdateLetsEncrypt {
            acme_challenge: input.acme_challenge.clone(),
            description: input.description.clone(),
            dns_target_creds: input.dns_target_creds.clone(),
            email: input.email.clone(),
            gcp_project: input.gcp_project.clone(),
            hosted_zone: input.hosted_zone.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            lets_encrypt_url: input.lets_encrypt_url.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            resource_group: input.resource_group.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_lets_encrypt(&req).await {
            Ok(result) => format::format_target_update_lets_encrypt(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_linked operation")]
    async fn target_update_linked(&self, Parameters(input): Parameters<TargetUpdateLinkedInput>) -> String {
        let req = crate::api::types::TargetUpdateLinked {
            add_hosts: input.add_hosts.clone(),
            description: input.description.clone(),
            hosts: input.hosts.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            rm_hosts: input.rm_hosts.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_linked(&req).await {
            Ok(result) => format::format_target_update_linked(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_open_ai operation")]
    async fn target_update_open_ai(&self, Parameters(input): Parameters<TargetUpdateOpenAiInput>) -> String {
        let req = crate::api::types::TargetUpdateOpenAi {
            api_key: input.api_key.clone(),
            api_key_id: input.api_key_id.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            model: input.model.clone(),
            name: input.name.clone(),
            new_comment: input.new_comment.clone(),
            new_name: input.new_name.clone(),
            openai_url: input.openai_url.clone(),
            organization_id: input.organization_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_open_ai(&req).await {
            Ok(result) => format::format_target_update_open_ai(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_ping operation")]
    async fn target_update_ping(&self, Parameters(input): Parameters<TargetUpdatePingInput>) -> String {
        let req = crate::api::types::TargetUpdatePing {
            administrative_port: input.administrative_port.clone(),
            authorization_port: input.authorization_port.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            ping_url: input.ping_url.clone(),
            privileged_user: input.privileged_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_ping(&req).await {
            Ok(result) => format::format_target_update_ping(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_rabbit_mq operation")]
    async fn target_update_rabbit_mq(&self, Parameters(input): Parameters<TargetUpdateRabbitMqInput>) -> String {
        let req = crate::api::types::TargetUpdateRabbitMq {
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            rabbitmq_server_password: input.rabbitmq_server_password.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_server_user: input.rabbitmq_server_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_rabbit_mq(&req).await {
            Ok(result) => format::format_target_update_rabbit_mq(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_salesforce operation")]
    async fn target_update_salesforce(&self, Parameters(input): Parameters<TargetUpdateSalesforceInput>) -> String {
        let req = crate::api::types::TargetUpdateSalesforce {
            app_private_key_data: input.app_private_key_data.clone(),
            auth_flow: input.auth_flow.clone(),
            ca_cert_data: input.ca_cert_data.clone(),
            ca_cert_name: input.ca_cert_name.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            description: input.description.clone(),
            email: input.email.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            security_token: input.security_token.clone(),
            tenant_url: input.tenant_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_salesforce(&req).await {
            Ok(result) => format::format_target_update_salesforce(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_sectigo operation")]
    async fn target_update_sectigo(&self, Parameters(input): Parameters<TargetUpdateSectigoInput>) -> String {
        let req = crate::api::types::TargetUpdateSectigo {
            certificate_profile_id: input.certificate_profile_id.clone(),
            customer_uri: input.customer_uri.clone(),
            description: input.description.clone(),
            external_requester: input.external_requester.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            organization_id: input.organization_id.clone(),
            password: input.password.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
        };
        match self.client.target_update_sectigo(&req).await {
            Ok(result) => format::format_target_update_sectigo(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_ssh operation")]
    async fn target_update_ssh(&self, Parameters(input): Parameters<TargetUpdateSshInput>) -> String {
        let req = crate::api::types::TargetUpdateSsh {
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            port: input.port.clone(),
            private_key: input.private_key.clone(),
            private_key_password: input.private_key_password.clone(),
            ssh_password: input.ssh_password.clone(),
            ssh_username: input.ssh_username.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_ssh(&req).await {
            Ok(result) => format::format_target_update_ssh(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_web operation")]
    async fn target_update_web(&self, Parameters(input): Parameters<TargetUpdateWebInput>) -> String {
        let req = crate::api::types::TargetUpdateWeb {
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.target_update_web(&req).await {
            Ok(result) => format::format_target_update_web(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_windows operation")]
    async fn target_update_windows(&self, Parameters(input): Parameters<TargetUpdateWindowsInput>) -> String {
        let req = crate::api::types::TargetUpdateWindows {
            certificate: input.certificate.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            domain: input.domain.clone(),
            hostname: input.hostname.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            password: input.password.clone(),
            port: input.port.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            use_tls: input.use_tls.clone(),
            username: input.username.clone(),
        };
        match self.client.target_update_windows(&req).await {
            Ok(result) => format::format_target_update_windows(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "target_update_zero_ssl operation")]
    async fn target_update_zero_ssl(&self, Parameters(input): Parameters<TargetUpdateZeroSslInput>) -> String {
        let req = crate::api::types::TargetUpdateZeroSsl {
            api_key: input.api_key.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_target_email: input.imap_target_email.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.target_update_zero_ssl(&req).await {
            Ok(result) => format::format_target_update_zero_ssl(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "tokenize operation")]
    async fn tokenize(&self, Parameters(input): Parameters<TokenizeInput>) -> String {
        let req = crate::api::types::Tokenize {
            json: input.json.clone(),
            plaintext: input.plaintext.clone(),
            token: input.token.clone(),
            tokenizer_name: input.tokenizer_name.clone(),
            tweak: input.tweak.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.tokenize(&req).await {
            Ok(result) => format::format_tokenize(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "tokenize_batch operation")]
    async fn tokenize_batch(&self, Parameters(_): Parameters<serde_json::Value>) -> String {
        match self.client.tokenize_batch().await {
            Ok(result) => format::format_tokenize_batch(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "uid_create_child_token operation")]
    async fn uid_create_child_token(&self, Parameters(input): Parameters<UidCreateChildTokenInput>) -> String {
        let req = crate::api::types::UidCreateChildToken {
            auth_method_name: input.auth_method_name.clone(),
            child_deny_inheritance: input.child_deny_inheritance.clone(),
            child_deny_rotate: input.child_deny_rotate.clone(),
            child_ttl: input.child_ttl.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            uid_token_id: input.uid_token_id.clone(),
        };
        match self.client.uid_create_child_token(&req).await {
            Ok(result) => format::format_uid_create_child_token(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "uid_generate_token operation")]
    async fn uid_generate_token(&self, Parameters(input): Parameters<UidGenerateTokenInput>) -> String {
        let req = crate::api::types::UidGenerateToken {
            auth_method_name: input.auth_method_name.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.uid_generate_token(&req).await {
            Ok(result) => format::format_uid_generate_token(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "uid_list_children operation")]
    async fn uid_list_children(&self, Parameters(input): Parameters<UidListChildrenInput>) -> String {
        let req = crate::api::types::UidListChildren {
            auth_method_name: input.auth_method_name.clone(),
            json: input.json.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.uid_list_children(&req).await {
            Ok(result) => format::format_uid_list_children(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "uid_revoke_token operation")]
    async fn uid_revoke_token(&self, Parameters(input): Parameters<UidRevokeTokenInput>) -> String {
        let req = crate::api::types::UidRevokeToken {
            auth_method_name: input.auth_method_name.clone(),
            json: input.json.clone(),
            revoke_token: input.revoke_token.clone(),
            revoke_type: input.revoke_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.uid_revoke_token(&req).await {
            Ok(result) => format::format_uid_revoke_token(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "uid_rotate_token operation")]
    async fn uid_rotate_token(&self, Parameters(input): Parameters<UidRotateTokenInput>) -> String {
        let req = crate::api::types::UidRotateToken {
            fork: input.fork.clone(),
            json: input.json.clone(),
            send_manual_ack_token: input.send_manual_ack_token.clone(),
            uid_token: input.uid_token.clone(),
            with_manual_ack: input.with_manual_ack.clone(),
        };
        match self.client.uid_rotate_token(&req).await {
            Ok(result) => format::format_uid_rotate_token(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "unwrap_token operation")]
    async fn unwrap_token(&self, Parameters(input): Parameters<UnwrapTokenInput>) -> String {
        let req = crate::api::types::UnwrapToken {
            json: input.json.clone(),
            shared_token: input.shared_token.clone(),
        };
        match self.client.unwrap_token(&req).await {
            Ok(result) => format::format_unwrap_token(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_account_settings operation")]
    async fn update_account_settings(&self, Parameters(input): Parameters<UpdateAccountSettingsInput>) -> String {
        let req = crate::api::types::UpdateAccountSettings {
            address: input.address.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_email_domains: input.allowed_email_domains.clone(),
            bound_ips: input.bound_ips.clone(),
            city: input.city.clone(),
            company_name: input.company_name.clone(),
            country: input.country.clone(),
            default_certificate_expiration_notification_days: input.default_certificate_expiration_notification_days.clone(),
            default_key_name: input.default_key_name.clone(),
            default_share_link_ttl_minutes: input.default_share_link_ttl_minutes.clone(),
            default_versioning: input.default_versioning.clone(),
            dp_enable_classic_key_protection: input.dp_enable_classic_key_protection.clone(),
            dynamic_secret_max_ttl: input.dynamic_secret_max_ttl.clone(),
            dynamic_secret_max_ttl_enable: input.dynamic_secret_max_ttl_enable.clone(),
            enable_ai_insights: input.enable_ai_insights.clone(),
            enable_default_certificate_expiration_event: input.enable_default_certificate_expiration_event.clone(),
            enable_item_sharing: input.enable_item_sharing.clone(),
            enable_password_expiration: input.enable_password_expiration.clone(),
            force_new_versions: input.force_new_versions.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            hide_personal_folder: input.hide_personal_folder.clone(),
            hide_static_password: input.hide_static_password.clone(),
            invalid_characters: input.invalid_characters.clone(),
            item_type: input.item_type.clone(),
            items_deletion_protection: input.items_deletion_protection.clone(),
            json: input.json.clone(),
            jwt_ttl_default: input.jwt_ttl_default.clone(),
            jwt_ttl_max: input.jwt_ttl_max.clone(),
            jwt_ttl_min: input.jwt_ttl_min.clone(),
            lock_allowed_client_type: input.lock_allowed_client_type.clone(),
            lock_bound_ips: input.lock_bound_ips.clone(),
            lock_default_key: input.lock_default_key.clone(),
            lock_gw_bound_ips: input.lock_gw_bound_ips.clone(),
            max_rotation_interval: input.max_rotation_interval.clone(),
            max_rotation_interval_enable: input.max_rotation_interval_enable.clone(),
            max_versions: input.max_versions.clone(),
            password_expiration_days: input.password_expiration_days.clone(),
            password_expiration_notification_days: input.password_expiration_notification_days.clone(),
            password_length: input.password_length.clone(),
            phone: input.phone.clone(),
            postal_code: input.postal_code.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usage_event_enable: input.usage_event_enable.clone(),
            usage_event_interval: input.usage_event_interval.clone(),
            usage_event_object_type: input.usage_event_object_type.clone(),
            use_capital_letters: input.use_capital_letters.clone(),
            use_lower_letters: input.use_lower_letters.clone(),
            use_numbers: input.use_numbers.clone(),
            use_special_characters: input.use_special_characters.clone(),
        };
        match self.client.update_account_settings(&req).await {
            Ok(result) => format::format_update_account_settings(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_artifactory_target operation")]
    async fn update_artifactory_target(&self, Parameters(input): Parameters<UpdateArtifactoryTargetInput>) -> String {
        let req = crate::api::types::UpdateArtifactoryTarget {
            artifactory_admin_name: input.artifactory_admin_name.clone(),
            artifactory_admin_pwd: input.artifactory_admin_pwd.clone(),
            base_url: input.base_url.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_artifactory_target(&req).await {
            Ok(result) => format::format_update_artifactory_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_assoc operation")]
    async fn update_assoc(&self, Parameters(input): Parameters<UpdateAssocInput>) -> String {
        let req = crate::api::types::UpdateAssoc {
            assoc_id: input.assoc_id.clone(),
            case_sensitive: input.case_sensitive.clone(),
            json: input.json.clone(),
            sub_claims: input.sub_claims.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_assoc(&req).await {
            Ok(result) => format::format_update_assoc(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method operation")]
    async fn update_auth_method(&self, Parameters(input): Parameters<UpdateAuthMethodInput>) -> String {
        let req = crate::api::types::UpdateAuthMethod {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_auth_method(&req).await {
            Ok(result) => format::format_update_auth_method(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_awsiam operation")]
    async fn update_auth_method_awsiam(&self, Parameters(input): Parameters<UpdateAuthMethodAwsiamInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodAwsiam {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_arn: input.bound_arn.clone(),
            bound_aws_account_id: input.bound_aws_account_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_role_id: input.bound_role_id.clone(),
            bound_role_name: input.bound_role_name.clone(),
            bound_user_id: input.bound_user_id.clone(),
            bound_user_name: input.bound_user_name.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            sts_url: input.sts_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_awsiam(&req).await {
            Ok(result) => format::format_update_auth_method_awsiam(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_azure_ad operation")]
    async fn update_auth_method_azure_ad(&self, Parameters(input): Parameters<UpdateAuthMethodAzureAdInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodAzureAd {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_group_id: input.bound_group_id.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_providers: input.bound_providers.clone(),
            bound_resource_id: input.bound_resource_id.clone(),
            bound_resource_names: input.bound_resource_names.clone(),
            bound_resource_types: input.bound_resource_types.clone(),
            bound_rg_id: input.bound_rg_id.clone(),
            bound_spid: input.bound_spid.clone(),
            bound_sub_id: input.bound_sub_id.clone(),
            bound_tenant_id: input.bound_tenant_id.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_azure_ad(&req).await {
            Ok(result) => format::format_update_auth_method_azure_ad(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_cert operation")]
    async fn update_auth_method_cert(&self, Parameters(input): Parameters<UpdateAuthMethodCertInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodCert {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_cors: input.allowed_cors.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_common_names: input.bound_common_names.clone(),
            bound_dns_sans: input.bound_dns_sans.clone(),
            bound_email_sans: input.bound_email_sans.clone(),
            bound_extensions: input.bound_extensions.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_organizational_units: input.bound_organizational_units.clone(),
            bound_uri_sans: input.bound_uri_sans.clone(),
            certificate_data: input.certificate_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            require_crl_dp: input.require_crl_dp.clone(),
            revoked_cert_ids: input.revoked_cert_ids.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_cert(&req).await {
            Ok(result) => format::format_update_auth_method_cert(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_gcp operation")]
    async fn update_auth_method_gcp(&self, Parameters(input): Parameters<UpdateAuthMethodGcpInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodGcp {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_labels: input.bound_labels.clone(),
            bound_projects: input.bound_projects.clone(),
            bound_regions: input.bound_regions.clone(),
            bound_service_accounts: input.bound_service_accounts.clone(),
            bound_zones: input.bound_zones.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            service_account_creds_data: input.service_account_creds_data.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_gcp(&req).await {
            Ok(result) => format::format_update_auth_method_gcp(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_k8s operation")]
    async fn update_auth_method_k8s(&self, Parameters(input): Parameters<UpdateAuthMethodK8sInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodK8s {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            bound_namespaces: input.bound_namespaces.clone(),
            bound_pod_names: input.bound_pod_names.clone(),
            bound_sa_names: input.bound_sa_names.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            public_key: input.public_key.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_auth_method_k8s(&req).await {
            Ok(result) => format::format_update_auth_method_k8s(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_ldap operation")]
    async fn update_auth_method_ldap(&self, Parameters(input): Parameters<UpdateAuthMethodLdapInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodLdap {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gen_key: input.gen_key.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            public_key_data: input.public_key_data.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_ldap(&req).await {
            Ok(result) => format::format_update_auth_method_ldap(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_o_auth2 operation")]
    async fn update_auth_method_o_auth2(&self, Parameters(input): Parameters<UpdateAuthMethodOAuth2Input>) -> String {
        let req = crate::api::types::UpdateAuthMethodOAuth2 {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_client_ids: input.bound_client_ids.clone(),
            bound_ips: input.bound_ips.clone(),
            cert: input.cert.clone(),
            cert_file_data: input.cert_file_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gateway_url: input.gateway_url.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwks_json_data: input.jwks_json_data.clone(),
            jwks_uri: input.jwks_uri.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_o_auth2(&req).await {
            Ok(result) => format::format_update_auth_method_o_auth2(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_oci operation")]
    async fn update_auth_method_oci(&self, Parameters(input): Parameters<UpdateAuthMethodOciInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodOci {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            group_ocid: input.group_ocid.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            tenant_ocid: input.tenant_ocid.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_auth_method_oci(&req).await {
            Ok(result) => format::format_update_auth_method_oci(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_oidc operation")]
    async fn update_auth_method_oidc(&self, Parameters(input): Parameters<UpdateAuthMethodOidcInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodOidc {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audience: input.audience.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            issuer: input.issuer.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            required_scopes: input.required_scopes.clone(),
            required_scopes_prefix: input.required_scopes_prefix.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_oidc(&req).await {
            Ok(result) => format::format_update_auth_method_oidc(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_saml operation")]
    async fn update_auth_method_saml(&self, Parameters(input): Parameters<UpdateAuthMethodSamlInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodSaml {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            allowed_redirect_uri: input.allowed_redirect_uri.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            idp_metadata_url: input.idp_metadata_url.clone(),
            idp_metadata_xml_data: input.idp_metadata_xml_data.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            subclaims_delimiters: input.subclaims_delimiters.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            unique_identifier: input.unique_identifier.clone(),
        };
        match self.client.update_auth_method_saml(&req).await {
            Ok(result) => format::format_update_auth_method_saml(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_auth_method_universal_identity operation")]
    async fn update_auth_method_universal_identity(&self, Parameters(input): Parameters<UpdateAuthMethodUniversalIdentityInput>) -> String {
        let req = crate::api::types::UpdateAuthMethodUniversalIdentity {
            access_expires: input.access_expires.clone(),
            allowed_client_type: input.allowed_client_type.clone(),
            audit_logs_claims: input.audit_logs_claims.clone(),
            bound_ips: input.bound_ips.clone(),
            delete_protection: input.delete_protection.clone(),
            deny_inheritance: input.deny_inheritance.clone(),
            deny_rotate: input.deny_rotate.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            force_sub_claims: input.force_sub_claims.clone(),
            gw_bound_ips: input.gw_bound_ips.clone(),
            json: input.json.clone(),
            jwt_ttl: input.jwt_ttl.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            product_type: input.product_type.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_auth_method_universal_identity(&req).await {
            Ok(result) => format::format_update_auth_method_universal_identity(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_aws_target operation")]
    async fn update_aws_target(&self, Parameters(input): Parameters<UpdateAwsTargetInput>) -> String {
        let req = crate::api::types::UpdateAwsTarget {
            access_key: input.access_key.clone(),
            access_key_id: input.access_key_id.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            generate_external_id: input.generate_external_id.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            region: input.region.clone(),
            role_arn: input.role_arn.clone(),
            session_token: input.session_token.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.update_aws_target(&req).await {
            Ok(result) => format::format_update_aws_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_aws_target_details operation")]
    async fn update_aws_target_details(&self, Parameters(input): Parameters<UpdateAwsTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateAwsTargetDetails {
            access_key: input.access_key.clone(),
            access_key_id: input.access_key_id.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            protection_key: input.protection_key.clone(),
            region: input.region.clone(),
            session_token: input.session_token.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_aws_target_details(&req).await {
            Ok(result) => format::format_update_aws_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_azure_target operation")]
    async fn update_azure_target(&self, Parameters(input): Parameters<UpdateAzureTargetInput>) -> String {
        let req = crate::api::types::UpdateAzureTarget {
            azure_cloud: input.azure_cloud.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            comment: input.comment.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            resource_group_name: input.resource_group_name.clone(),
            resource_name: input.resource_name.clone(),
            subscription_id: input.subscription_id.clone(),
            tenant_id: input.tenant_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.update_azure_target(&req).await {
            Ok(result) => format::format_update_azure_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_certificate_value operation")]
    async fn update_certificate_value(&self, Parameters(input): Parameters<UpdateCertificateValueInput>) -> String {
        let req = crate::api::types::UpdateCertificateValue {
            add_tag: input.add_tag.clone(),
            certificate_data: input.certificate_data.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            format: input.format.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            key_data: input.key_data.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            rm_tag: input.rm_tag.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_certificate_value(&req).await {
            Ok(result) => format::format_update_certificate_value(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_classic_key_certificate operation")]
    async fn update_classic_key_certificate(&self, Parameters(input): Parameters<UpdateClassicKeyCertificateInput>) -> String {
        let req = crate::api::types::UpdateClassicKeyCertificate {
            cert_file_data: input.cert_file_data.clone(),
            certificate_format: input.certificate_format.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_classic_key_certificate(&req).await {
            Ok(result) => format::format_update_classic_key_certificate(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_db_target operation")]
    async fn update_db_target(&self, Parameters(input): Parameters<UpdateDbTargetInput>) -> String {
        let req = crate::api::types::UpdateDbTarget {
            azure_client_id: input.azure_client_id.clone(),
            azure_client_secret: input.azure_client_secret.clone(),
            azure_tenant_id: input.azure_tenant_id.clone(),
            cloud_service_provider: input.cloud_service_provider.clone(),
            cluster_mode: input.cluster_mode.clone(),
            comment: input.comment.clone(),
            connection_type: input.connection_type.clone(),
            db_name: input.db_name.clone(),
            db_server_certificates: input.db_server_certificates.clone(),
            db_server_name: input.db_server_name.clone(),
            db_type: input.db_type.clone(),
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mongodb_atlas: input.mongodb_atlas.clone(),
            mongodb_atlas_api_private_key: input.mongodb_atlas_api_private_key.clone(),
            mongodb_atlas_api_public_key: input.mongodb_atlas_api_public_key.clone(),
            mongodb_atlas_project_id: input.mongodb_atlas_project_id.clone(),
            mongodb_default_auth_db: input.mongodb_default_auth_db.clone(),
            mongodb_uri_options: input.mongodb_uri_options.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            oracle_service_name: input.oracle_service_name.clone(),
            oracle_wallet_login_type: input.oracle_wallet_login_type.clone(),
            oracle_wallet_p12_file_data: input.oracle_wallet_p12_file_data.clone(),
            oracle_wallet_sso_file_data: input.oracle_wallet_sso_file_data.clone(),
            parent_target_name: input.parent_target_name.clone(),
            port: input.port.clone(),
            pwd: input.pwd.clone(),
            snowflake_account: input.snowflake_account.clone(),
            snowflake_api_private_key: input.snowflake_api_private_key.clone(),
            snowflake_api_private_key_password: input.snowflake_api_private_key_password.clone(),
            ssl: input.ssl.clone(),
            ssl_certificate: input.ssl_certificate.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            user_name: input.user_name.clone(),
        };
        match self.client.update_db_target(&req).await {
            Ok(result) => format::format_update_db_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_db_target_details operation")]
    async fn update_db_target_details(&self, Parameters(input): Parameters<UpdateDbTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateDbTargetDetails {
            db_type: input.db_type.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            mongo_db_name: input.mongo_db_name.clone(),
            mongo_uri: input.mongo_uri.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            port: input.port.clone(),
            protection_key: input.protection_key.clone(),
            pwd: input.pwd.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_name: input.user_name.clone(),
        };
        match self.client.update_db_target_details(&req).await {
            Ok(result) => format::format_update_db_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_dockerhub_target operation")]
    async fn update_dockerhub_target(&self, Parameters(input): Parameters<UpdateDockerhubTargetInput>) -> String {
        let req = crate::api::types::UpdateDockerhubTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            dockerhub_password: input.dockerhub_password.clone(),
            dockerhub_username: input.dockerhub_username.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_dockerhub_target(&req).await {
            Ok(result) => format::format_update_dockerhub_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_eks_target operation")]
    async fn update_eks_target(&self, Parameters(input): Parameters<UpdateEksTargetInput>) -> String {
        let req = crate::api::types::UpdateEksTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            eks_access_key_id: input.eks_access_key_id.clone(),
            eks_cluster_ca_cert: input.eks_cluster_ca_cert.clone(),
            eks_cluster_endpoint: input.eks_cluster_endpoint.clone(),
            eks_cluster_name: input.eks_cluster_name.clone(),
            eks_region: input.eks_region.clone(),
            eks_secret_access_key: input.eks_secret_access_key.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.update_eks_target(&req).await {
            Ok(result) => format::format_update_eks_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_event_forwarder operation")]
    async fn update_event_forwarder(&self, Parameters(input): Parameters<UpdateEventForwarderInput>) -> String {
        let req = crate::api::types::UpdateEventForwarder {
            admin_name: input.admin_name.clone(),
            auth_type: input.auth_type.clone(),
            client_id: input.client_id.clone(),
            description: input.description.clone(),
            email_to: input.email_to.clone(),
            enable: input.enable.clone(),
            event_source_locations: input.event_source_locations.clone(),
            event_types: input.event_types.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_comment: input.new_comment.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_email: input.user_email.clone(),
        };
        match self.client.update_event_forwarder(&req).await {
            Ok(result) => format::format_update_event_forwarder(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_gcp_target operation")]
    async fn update_gcp_target(&self, Parameters(input): Parameters<UpdateGcpTargetInput>) -> String {
        let req = crate::api::types::UpdateGcpTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.update_gcp_target(&req).await {
            Ok(result) => format::format_update_gcp_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_github_target operation")]
    async fn update_github_target(&self, Parameters(input): Parameters<UpdateGithubTargetInput>) -> String {
        let req = crate::api::types::UpdateGithubTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            github_app_id: input.github_app_id.clone(),
            github_app_private_key: input.github_app_private_key.clone(),
            github_base_url: input.github_base_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_github_target(&req).await {
            Ok(result) => format::format_update_github_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_gitlab_target operation")]
    async fn update_gitlab_target(&self, Parameters(input): Parameters<UpdateGitlabTargetInput>) -> String {
        let req = crate::api::types::UpdateGitlabTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            gitlab_access_token: input.gitlab_access_token.clone(),
            gitlab_certificate: input.gitlab_certificate.clone(),
            gitlab_url: input.gitlab_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_gitlab_target(&req).await {
            Ok(result) => format::format_update_gitlab_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_gke_target operation")]
    async fn update_gke_target(&self, Parameters(input): Parameters<UpdateGkeTargetInput>) -> String {
        let req = crate::api::types::UpdateGkeTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            gke_account_key: input.gke_account_key.clone(),
            gke_cluster_cert: input.gke_cluster_cert.clone(),
            gke_cluster_endpoint: input.gke_cluster_endpoint.clone(),
            gke_cluster_name: input.gke_cluster_name.clone(),
            gke_service_account_email: input.gke_service_account_email.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            use_gw_cloud_identity: input.use_gw_cloud_identity.clone(),
        };
        match self.client.update_gke_target(&req).await {
            Ok(result) => format::format_update_gke_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_global_sign_atlas_target operation")]
    async fn update_global_sign_atlas_target(&self, Parameters(input): Parameters<UpdateGlobalSignAtlasTargetInput>) -> String {
        let req = crate::api::types::UpdateGlobalSignAtlasTarget {
            api_key: input.api_key.clone(),
            api_secret: input.api_secret.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            mtls_cert_data_base64: input.mtls_cert_data_base64.clone(),
            mtls_key_data_base64: input.mtls_key_data_base64.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_global_sign_atlas_target(&req).await {
            Ok(result) => format::format_update_global_sign_atlas_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_global_sign_target operation")]
    async fn update_global_sign_target(&self, Parameters(input): Parameters<UpdateGlobalSignTargetInput>) -> String {
        let req = crate::api::types::UpdateGlobalSignTarget {
            comment: input.comment.clone(),
            contact_email: input.contact_email.clone(),
            contact_first_name: input.contact_first_name.clone(),
            contact_last_name: input.contact_last_name.clone(),
            contact_phone: input.contact_phone.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            profile_id: input.profile_id.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            username: input.username.clone(),
        };
        match self.client.update_global_sign_target(&req).await {
            Ok(result) => format::format_update_global_sign_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_godaddy_target operation")]
    async fn update_godaddy_target(&self, Parameters(input): Parameters<UpdateGodaddyTargetInput>) -> String {
        let req = crate::api::types::UpdateGodaddyTarget {
            api_key: input.api_key.clone(),
            comment: input.comment.clone(),
            customer_id: input.customer_id.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            secret: input.secret.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_godaddy_target(&req).await {
            Ok(result) => format::format_update_godaddy_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_group operation")]
    async fn update_group(&self, Parameters(input): Parameters<UpdateGroupInput>) -> String {
        let req = crate::api::types::UpdateGroup {
            description: input.description.clone(),
            group_alias: input.group_alias.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_assignment: input.user_assignment.clone(),
        };
        match self.client.update_group(&req).await {
            Ok(result) => format::format_update_group(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_hashi_vault_target operation")]
    async fn update_hashi_vault_target(&self, Parameters(input): Parameters<UpdateHashiVaultTargetInput>) -> String {
        let req = crate::api::types::UpdateHashiVaultTarget {
            description: input.description.clone(),
            hashi_url: input.hashi_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            namespace: input.namespace.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            vault_token: input.vault_token.clone(),
        };
        match self.client.update_hashi_vault_target(&req).await {
            Ok(result) => format::format_update_hashi_vault_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_item operation")]
    async fn update_item(&self, Parameters(input): Parameters<UpdateItemInput>) -> String {
        let req = crate::api::types::UpdateItem {
            provider_type: input.provider_type.clone(),
            accessibility: input.accessibility.clone(),
            add_tag: input.add_tag.clone(),
            cert_file_data: input.cert_file_data.clone(),
            certificate_format: input.certificate_format.clone(),
            change_event: input.change_event.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            gcp_sm_regions: input.gcp_sm_regions.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_metadata: input.new_metadata.clone(),
            new_name: input.new_name.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            secure_access_add_host: input.secure_access_add_host.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_allow_port_forwading: input.secure_access_allow_port_forwading.clone(),
            secure_access_api: input.secure_access_api.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_aws_region: input.secure_access_aws_region.clone(),
            secure_access_bastion_api: input.secure_access_bastion_api.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_bastion_ssh: input.secure_access_bastion_ssh.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_cluster_endpoint: input.secure_access_cluster_endpoint.clone(),
            secure_access_dashboard_url: input.secure_access_dashboard_url.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_gateway: input.secure_access_gateway.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rd_gateway_server: input.secure_access_rd_gateway_server.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_rm_host: input.secure_access_rm_host.clone(),
            secure_access_ssh: input.secure_access_ssh.clone(),
            secure_access_ssh_creds: input.secure_access_ssh_creds.clone(),
            secure_access_ssh_creds_user: input.secure_access_ssh_creds_user.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_use_internal_bastion: input.secure_access_use_internal_bastion.clone(),
            secure_access_use_internal_ssh_access: input.secure_access_use_internal_ssh_access.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_item(&req).await {
            Ok(result) => format::format_update_item(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_native_k8s_target operation")]
    async fn update_native_k8s_target(&self, Parameters(input): Parameters<UpdateNativeK8sTargetInput>) -> String {
        let req = crate::api::types::UpdateNativeK8sTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            k8s_auth_type: input.k8s_auth_type.clone(),
            k8s_client_certificate: input.k8s_client_certificate.clone(),
            k8s_client_key: input.k8s_client_key.clone(),
            k8s_cluster_ca_cert: input.k8s_cluster_ca_cert.clone(),
            k8s_cluster_endpoint: input.k8s_cluster_endpoint.clone(),
            k8s_cluster_name: input.k8s_cluster_name.clone(),
            k8s_cluster_token: input.k8s_cluster_token.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            use_gw_service_account: input.use_gw_service_account.clone(),
        };
        match self.client.update_native_k8s_target(&req).await {
            Ok(result) => format::format_update_native_k8s_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_ldap_target operation")]
    async fn update_ldap_target(&self, Parameters(input): Parameters<UpdateLdapTargetInput>) -> String {
        let req = crate::api::types::UpdateLdapTarget {
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            server_type: input.server_type.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_ldap_target(&req).await {
            Ok(result) => format::format_update_ldap_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_ldap_target_details operation")]
    async fn update_ldap_target_details(&self, Parameters(input): Parameters<UpdateLdapTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateLdapTargetDetails {
            bind_dn: input.bind_dn.clone(),
            bind_dn_password: input.bind_dn_password.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            ldap_ca_cert: input.ldap_ca_cert.clone(),
            ldap_url: input.ldap_url.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            protection_key: input.protection_key.clone(),
            token: input.token.clone(),
            token_expiration: input.token_expiration.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_ldap_target_details(&req).await {
            Ok(result) => format::format_update_ldap_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_linked_target operation")]
    async fn update_linked_target(&self, Parameters(input): Parameters<UpdateLinkedTargetInput>) -> String {
        let req = crate::api::types::UpdateLinkedTarget {
            add_hosts: input.add_hosts.clone(),
            description: input.description.clone(),
            hosts: input.hosts.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            rm_hosts: input.rm_hosts.clone(),
            token: input.token.clone(),
            type: input.type.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_linked_target(&req).await {
            Ok(result) => format::format_update_linked_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_oidc_app operation")]
    async fn update_oidc_app(&self, Parameters(input): Parameters<UpdateOidcAppInput>) -> String {
        let req = crate::api::types::UpdateOidcApp {
            audience: input.audience.clone(),
            json: input.json.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            permission_assignment: input.permission_assignment.clone(),
            public: input.public.clone(),
            redirect_uris: input.redirect_uris.clone(),
            scopes: input.scopes.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_oidc_app(&req).await {
            Ok(result) => format::format_update_oidc_app(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_ping_target operation")]
    async fn update_ping_target(&self, Parameters(input): Parameters<UpdatePingTargetInput>) -> String {
        let req = crate::api::types::UpdatePingTarget {
            administrative_port: input.administrative_port.clone(),
            authorization_port: input.authorization_port.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            ping_url: input.ping_url.clone(),
            privileged_user: input.privileged_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_ping_target(&req).await {
            Ok(result) => format::format_update_ping_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_pki_cert_issuer operation")]
    async fn update_pki_cert_issuer(&self, Parameters(input): Parameters<UpdatePkiCertIssuerInput>) -> String {
        let req = crate::api::types::UpdatePkiCertIssuer {
            add_tag: input.add_tag.clone(),
            allow_any_name: input.allow_any_name.clone(),
            allow_copy_ext_from_csr: input.allow_copy_ext_from_csr.clone(),
            allow_subdomains: input.allow_subdomains.clone(),
            allowed_domains: input.allowed_domains.clone(),
            allowed_extra_extensions: input.allowed_extra_extensions.clone(),
            allowed_ip_sans: input.allowed_ip_sans.clone(),
            allowed_uri_sans: input.allowed_uri_sans.clone(),
            auto_renew: input.auto_renew.clone(),
            client_flag: input.client_flag.clone(),
            code_signing_flag: input.code_signing_flag.clone(),
            country: input.country.clone(),
            create_private_crl: input.create_private_crl.clone(),
            create_private_ocsp: input.create_private_ocsp.clone(),
            create_public_crl: input.create_public_crl.clone(),
            create_public_ocsp: input.create_public_ocsp.clone(),
            critical_key_usage: input.critical_key_usage.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            destination_path: input.destination_path.clone(),
            disable_wildcards: input.disable_wildcards.clone(),
            enable_acme: input.enable_acme.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            gw_cluster_url: input.gw_cluster_url.clone(),
            is_ca: input.is_ca.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            key_usage: input.key_usage.clone(),
            locality: input.locality.clone(),
            max_path_len: input.max_path_len.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            not_enforce_hostnames: input.not_enforce_hostnames.clone(),
            not_require_cn: input.not_require_cn.clone(),
            ocsp_ttl: input.ocsp_ttl.clone(),
            organizational_units: input.organizational_units.clone(),
            organizations: input.organizations.clone(),
            postal_code: input.postal_code.clone(),
            protect_certificates: input.protect_certificates.clone(),
            province: input.province.clone(),
            rm_tag: input.rm_tag.clone(),
            scheduled_renew: input.scheduled_renew.clone(),
            server_flag: input.server_flag.clone(),
            signer_key_name: input.signer_key_name.clone(),
            street_address: input.street_address.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_pki_cert_issuer(&req).await {
            Ok(result) => format::format_update_pki_cert_issuer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_rabbit_mq_target operation")]
    async fn update_rabbit_mq_target(&self, Parameters(input): Parameters<UpdateRabbitMqTargetInput>) -> String {
        let req = crate::api::types::UpdateRabbitMqTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            rabbitmq_server_password: input.rabbitmq_server_password.clone(),
            rabbitmq_server_uri: input.rabbitmq_server_uri.clone(),
            rabbitmq_server_user: input.rabbitmq_server_user.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_rabbit_mq_target(&req).await {
            Ok(result) => format::format_update_rabbit_mq_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_rabbit_mq_target_details operation")]
    async fn update_rabbit_mq_target_details(&self, Parameters(input): Parameters<UpdateRabbitMqTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateRabbitMqTargetDetails {
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            protection_key: input.protection_key.clone(),
            pwd: input.pwd.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            uri: input.uri.clone(),
            user: input.user.clone(),
        };
        match self.client.update_rabbit_mq_target_details(&req).await {
            Ok(result) => format::format_update_rabbit_mq_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_rdp_target_details operation")]
    async fn update_rdp_target_details(&self, Parameters(input): Parameters<UpdateRdpTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateRdpTargetDetails {
            admin_name: input.admin_name.clone(),
            admin_pwd: input.admin_pwd.clone(),
            host_name: input.host_name.clone(),
            host_port: input.host_port.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            protection_key: input.protection_key.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_rdp_target_details(&req).await {
            Ok(result) => format::format_update_rdp_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_role operation")]
    async fn update_role(&self, Parameters(input): Parameters<UpdateRoleInput>) -> String {
        let req = crate::api::types::UpdateRole {
            analytics_access: input.analytics_access.clone(),
            audit_access: input.audit_access.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            event_center_access: input.event_center_access.clone(),
            event_forwarder_access: input.event_forwarder_access.clone(),
            gw_analytics_access: input.gw_analytics_access.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            new_comment: input.new_comment.clone(),
            new_name: input.new_name.clone(),
            reverse_rbac_access: input.reverse_rbac_access.clone(),
            sra_reports_access: input.sra_reports_access.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usage_reports_access: input.usage_reports_access.clone(),
        };
        match self.client.update_role(&req).await {
            Ok(result) => format::format_update_role(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_rotated_secret operation")]
    async fn update_rotated_secret(&self, Parameters(input): Parameters<UpdateRotatedSecretInput>) -> String {
        let req = crate::api::types::UpdateRotatedSecret {
            provider_type: input.provider_type.clone(),
            add_tag: input.add_tag.clone(),
            api_id: input.api_id.clone(),
            api_key: input.api_key.clone(),
            auto_rotate: input.auto_rotate.clone(),
            aws_region: input.aws_region.clone(),
            custom_payload: input.custom_payload.clone(),
            description: input.description.clone(),
            gcp_key: input.gcp_key.clone(),
            grace_rotation: input.grace_rotation.clone(),
            host_provider: input.host_provider.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            name: input.name.clone(),
            new_metadata: input.new_metadata.clone(),
            new_name: input.new_name.clone(),
            new_version: input.new_version.clone(),
            rm_tag: input.rm_tag.clone(),
            rotate_after_disconnect: input.rotate_after_disconnect.clone(),
            rotated_password: input.rotated_password.clone(),
            rotated_username: input.rotated_username.clone(),
            rotation_hour: input.rotation_hour.clone(),
            rotation_interval: input.rotation_interval.clone(),
            rotator_creds_type: input.rotator_creds_type.clone(),
            rotator_custom_cmd: input.rotator_custom_cmd.clone(),
            same_password: input.same_password.clone(),
            secure_access_allow_external_user: input.secure_access_allow_external_user.clone(),
            secure_access_aws_account_id: input.secure_access_aws_account_id.clone(),
            secure_access_aws_native_cli: input.secure_access_aws_native_cli.clone(),
            secure_access_bastion_issuer: input.secure_access_bastion_issuer.clone(),
            secure_access_certificate_issuer: input.secure_access_certificate_issuer.clone(),
            secure_access_db_name: input.secure_access_db_name.clone(),
            secure_access_db_schema: input.secure_access_db_schema.clone(),
            secure_access_disable_concurrent_connections: input.secure_access_disable_concurrent_connections.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_rdp_domain: input.secure_access_rdp_domain.clone(),
            secure_access_rdp_user: input.secure_access_rdp_user.clone(),
            secure_access_url: input.secure_access_url.clone(),
            secure_access_web: input.secure_access_web.clone(),
            secure_access_web_browsing: input.secure_access_web_browsing.clone(),
            secure_access_web_proxy: input.secure_access_web_proxy.clone(),
            ssh_password: input.ssh_password.clone(),
            ssh_username: input.ssh_username.clone(),
            storage_account_key_name: input.storage_account_key_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            user_attribute: input.user_attribute.clone(),
            user_dn: input.user_dn.clone(),
        };
        match self.client.update_rotated_secret(&req).await {
            Ok(result) => format::format_update_rotated_secret(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_rotation_settings operation")]
    async fn update_rotation_settings(&self, Parameters(input): Parameters<UpdateRotationSettingsInput>) -> String {
        let req = crate::api::types::UpdateRotationSettings {
            auto_rotate: input.auto_rotate.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            rotation_event_in: input.rotation_event_in.clone(),
            rotation_interval: input.rotation_interval.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_rotation_settings(&req).await {
            Ok(result) => format::format_update_rotation_settings(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_salesforce_target operation")]
    async fn update_salesforce_target(&self, Parameters(input): Parameters<UpdateSalesforceTargetInput>) -> String {
        let req = crate::api::types::UpdateSalesforceTarget {
            app_private_key_data: input.app_private_key_data.clone(),
            auth_flow: input.auth_flow.clone(),
            ca_cert_data: input.ca_cert_data.clone(),
            ca_cert_name: input.ca_cert_name.clone(),
            client_id: input.client_id.clone(),
            client_secret: input.client_secret.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            email: input.email.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            password: input.password.clone(),
            security_token: input.security_token.clone(),
            tenant_url: input.tenant_url.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_salesforce_target(&req).await {
            Ok(result) => format::format_update_salesforce_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_secret_val operation")]
    async fn update_secret_val(&self, Parameters(input): Parameters<UpdateSecretValInput>) -> String {
        let req = crate::api::types::UpdateSecretVal {
            accessibility: input.accessibility.clone(),
            custom_field: input.custom_field.clone(),
            format: input.format.clone(),
            inject_url: input.inject_url.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            last_version: input.last_version.clone(),
            multiline: input.multiline.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            password: input.password.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            username: input.username.clone(),
            value: input.value.clone(),
        };
        match self.client.update_secret_val(&req).await {
            Ok(result) => format::format_update_secret_val(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_ssh_cert_issuer operation")]
    async fn update_ssh_cert_issuer(&self, Parameters(input): Parameters<UpdateSshCertIssuerInput>) -> String {
        let req = crate::api::types::UpdateSshCertIssuer {
            provider_type: input.provider_type.clone(),
            add_tag: input.add_tag.clone(),
            allowed_users: input.allowed_users.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            extensions: input.extensions.clone(),
            external_username: input.external_username.clone(),
            fixed_user_claim_keyname: input.fixed_user_claim_keyname.clone(),
            host_provider: input.host_provider.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            principals: input.principals.clone(),
            rm_tag: input.rm_tag.clone(),
            secure_access_api: input.secure_access_api.clone(),
            secure_access_bastion_api: input.secure_access_bastion_api.clone(),
            secure_access_bastion_ssh: input.secure_access_bastion_ssh.clone(),
            secure_access_enable: input.secure_access_enable.clone(),
            secure_access_enforce_hosts_restriction: input.secure_access_enforce_hosts_restriction.clone(),
            secure_access_gateway: input.secure_access_gateway.clone(),
            secure_access_host: input.secure_access_host.clone(),
            secure_access_ssh: input.secure_access_ssh.clone(),
            secure_access_ssh_creds_user: input.secure_access_ssh_creds_user.clone(),
            secure_access_use_internal_bastion: input.secure_access_use_internal_bastion.clone(),
            secure_access_use_internal_ssh_access: input.secure_access_use_internal_ssh_access.clone(),
            signer_key_name: input.signer_key_name.clone(),
            token: input.token.clone(),
            ttl: input.ttl.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_ssh_cert_issuer(&req).await {
            Ok(result) => format::format_update_ssh_cert_issuer(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_ssh_target operation")]
    async fn update_ssh_target(&self, Parameters(input): Parameters<UpdateSshTargetInput>) -> String {
        let req = crate::api::types::UpdateSshTarget {
            description: input.description.clone(),
            host: input.host.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            port: input.port.clone(),
            private_key: input.private_key.clone(),
            private_key_password: input.private_key_password.clone(),
            ssh_password: input.ssh_password.clone(),
            ssh_username: input.ssh_username.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_ssh_target(&req).await {
            Ok(result) => format::format_update_ssh_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_ssh_target_details operation")]
    async fn update_ssh_target_details(&self, Parameters(input): Parameters<UpdateSshTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateSshTargetDetails {
            host: input.host.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            port: input.port.clone(),
            private_key: input.private_key.clone(),
            private_key_password: input.private_key_password.clone(),
            protection_key: input.protection_key.clone(),
            ssh_password: input.ssh_password.clone(),
            ssh_username: input.ssh_username.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_ssh_target_details(&req).await {
            Ok(result) => format::format_update_ssh_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_target operation")]
    async fn update_target(&self, Parameters(input): Parameters<UpdateTargetInput>) -> String {
        let req = crate::api::types::UpdateTarget {
            description: input.description.clone(),
            json: input.json.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_comment: input.new_comment.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.update_target(&req).await {
            Ok(result) => format::format_update_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_target_details operation")]
    async fn update_target_details(&self, Parameters(input): Parameters<UpdateTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateTargetDetails {
            json: input.json.clone(),
        };
        match self.client.update_target_details(&req).await {
            Ok(result) => format::format_update_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_web_target operation")]
    async fn update_web_target(&self, Parameters(input): Parameters<UpdateWebTargetInput>) -> String {
        let req = crate::api::types::UpdateWebTarget {
            comment: input.comment.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            url: input.url.clone(),
        };
        match self.client.update_web_target(&req).await {
            Ok(result) => format::format_update_web_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_web_target_details operation")]
    async fn update_web_target_details(&self, Parameters(input): Parameters<UpdateWebTargetDetailsInput>) -> String {
        let req = crate::api::types::UpdateWebTargetDetails {
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            name: input.name.clone(),
            new_version: input.new_version.clone(),
            protection_key: input.protection_key.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            url: input.url.clone(),
        };
        match self.client.update_web_target_details(&req).await {
            Ok(result) => format::format_update_web_target_details(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_windows_target operation")]
    async fn update_windows_target(&self, Parameters(input): Parameters<UpdateWindowsTargetInput>) -> String {
        let req = crate::api::types::UpdateWindowsTarget {
            certificate: input.certificate.clone(),
            connection_type: input.connection_type.clone(),
            description: input.description.clone(),
            domain: input.domain.clone(),
            hostname: input.hostname.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            parent_target_name: input.parent_target_name.clone(),
            password: input.password.clone(),
            port: input.port.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
            use_tls: input.use_tls.clone(),
            username: input.username.clone(),
        };
        match self.client.update_windows_target(&req).await {
            Ok(result) => format::format_update_windows_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "update_zero_ssl_target operation")]
    async fn update_zero_ssl_target(&self, Parameters(input): Parameters<UpdateZeroSslTargetInput>) -> String {
        let req = crate::api::types::UpdateZeroSslTarget {
            api_key: input.api_key.clone(),
            comment: input.comment.clone(),
            description: input.description.clone(),
            imap_fqdn: input.imap_fqdn.clone(),
            imap_password: input.imap_password.clone(),
            imap_port: input.imap_port.clone(),
            imap_target_email: input.imap_target_email.clone(),
            imap_username: input.imap_username.clone(),
            json: input.json.clone(),
            keep_prev_version: input.keep_prev_version.clone(),
            key: input.key.clone(),
            max_versions: input.max_versions.clone(),
            name: input.name.clone(),
            new_name: input.new_name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            update_version: input.update_version.clone(),
        };
        match self.client.update_zero_ssl_target(&req).await {
            Ok(result) => format::format_update_zero_ssl_target(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "upload_rsa operation")]
    async fn upload_rsa(&self, Parameters(input): Parameters<UploadRsaInput>) -> String {
        let req = crate::api::types::UploadRsa {
            alg: input.alg.clone(),
            cert_file_data: input.cert_file_data.clone(),
            certificate_format: input.certificate_format.clone(),
            customer_frg_id: input.customer_frg_id.clone(),
            delete_protection: input.delete_protection.clone(),
            description: input.description.clone(),
            expiration_event_in: input.expiration_event_in.clone(),
            item_custom_fields: input.item_custom_fields.clone(),
            json: input.json.clone(),
            metadata: input.metadata.clone(),
            name: input.name.clone(),
            overwrite: input.overwrite.clone(),
            rsa_file_data: input.rsa_file_data.clone(),
            split_level: input.split_level.clone(),
            tag: input.tag.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.upload_rsa(&req).await {
            Ok(result) => format::format_upload_rsa(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "usc_create operation")]
    async fn usc_create(&self, Parameters(input): Parameters<UscCreateInput>) -> String {
        let req = crate::api::types::UscCreate {
            binary_value: input.binary_value.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            namespace: input.namespace.clone(),
            object_type: input.object_type.clone(),
            pfx_password: input.pfx_password.clone(),
            region: input.region.clone(),
            secret_name: input.secret_name.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_encryption_key: input.usc_encryption_key.clone(),
            usc_name: input.usc_name.clone(),
            value: input.value.clone(),
        };
        match self.client.usc_create(&req).await {
            Ok(result) => format::format_usc_create(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "usc_delete operation")]
    async fn usc_delete(&self, Parameters(input): Parameters<UscDeleteInput>) -> String {
        let req = crate::api::types::UscDelete {
            force_delete: input.force_delete.clone(),
            json: input.json.clone(),
            namespace: input.namespace.clone(),
            secret_id: input.secret_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_name: input.usc_name.clone(),
        };
        match self.client.usc_delete(&req).await {
            Ok(result) => format::format_usc_delete(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "usc_get operation")]
    async fn usc_get(&self, Parameters(input): Parameters<UscGetInput>) -> String {
        let req = crate::api::types::UscGet {
            json: input.json.clone(),
            namespace: input.namespace.clone(),
            secret_id: input.secret_id.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_name: input.usc_name.clone(),
            version_id: input.version_id.clone(),
        };
        match self.client.usc_get(&req).await {
            Ok(result) => format::format_usc_get(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "usc_list operation")]
    async fn usc_list(&self, Parameters(input): Parameters<UscListInput>) -> String {
        let req = crate::api::types::UscList {
            json: input.json.clone(),
            object_type: input.object_type.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_name: input.usc_name.clone(),
        };
        match self.client.usc_list(&req).await {
            Ok(result) => format::format_usc_list(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "usc_update operation")]
    async fn usc_update(&self, Parameters(input): Parameters<UscUpdateInput>) -> String {
        let req = crate::api::types::UscUpdate {
            binary_value: input.binary_value.clone(),
            description: input.description.clone(),
            json: input.json.clone(),
            namespace: input.namespace.clone(),
            pfx_password: input.pfx_password.clone(),
            secret_id: input.secret_id.clone(),
            tags: input.tags.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            usc_encryption_key: input.usc_encryption_key.clone(),
            usc_name: input.usc_name.clone(),
            value: input.value.clone(),
        };
        match self.client.usc_update(&req).await {
            Ok(result) => format::format_usc_update(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "get_last_user_event_status operation")]
    async fn get_last_user_event_status(&self, Parameters(input): Parameters<GetLastUserEventStatusInput>) -> String {
        let req = crate::api::types::GetLastUserEventStatus {
            event_source: input.event_source.clone(),
            event_type: input.event_type.clone(),
            item_name: input.item_name.clone(),
            item_type: input.item_type.clone(),
            json: input.json.clone(),
            time_back: input.time_back.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.get_last_user_event_status(&req).await {
            Ok(result) => format::format_get_last_user_event_status(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "validate_certificate_challenge operation")]
    async fn validate_certificate_challenge(&self, Parameters(input): Parameters<ValidateCertificateChallengeInput>) -> String {
        let req = crate::api::types::ValidateCertificateChallenge {
            result: input.result.clone(),
            cert_display_id: input.cert_display_id.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            timeout: input.timeout.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.validate_certificate_challenge(&req).await {
            Ok(result) => format::format_validate_certificate_challenge(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "validate_token operation")]
    async fn validate_token(&self, Parameters(input): Parameters<ValidateTokenInput>) -> String {
        let req = crate::api::types::ValidateToken {
            json: input.json.clone(),
            token: input.token.clone(),
        };
        match self.client.validate_token(&req).await {
            Ok(result) => format::format_validate_token(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "vault_address operation")]
    async fn vault_address(&self, Parameters(input): Parameters<VaultAddressInput>) -> String {
        let req = crate::api::types::VaultAddress {
            access_id: input.access_id.clone(),
            json: input.json.clone(),
        };
        match self.client.vault_address(&req).await {
            Ok(result) => format::format_vault_address(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "verify_data_with_classic_key operation")]
    async fn verify_data_with_classic_key(&self, Parameters(input): Parameters<VerifyDataWithClassicKeyInput>) -> String {
        let req = crate::api::types::VerifyDataWithClassicKey {
            data: input.data.clone(),
            display_id: input.display_id.clone(),
            hashed: input.hashed.clone(),
            hashing_method: input.hashing_method.clone(),
            json: input.json.clone(),
            name: input.name.clone(),
            signature: input.signature.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.verify_data_with_classic_key(&req).await {
            Ok(result) => format::format_verify_data_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "verify_ec_dsa operation")]
    async fn verify_ec_dsa(&self, Parameters(input): Parameters<VerifyEcDsaInput>) -> String {
        let req = crate::api::types::VerifyEcDsa {
            display_id: input.display_id.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            message: input.message.clone(),
            prehashed: input.prehashed.clone(),
            signature: input.signature.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.verify_ec_dsa(&req).await {
            Ok(result) => format::format_verify_ec_dsa(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "verify_gpg operation")]
    async fn verify_gpg(&self, Parameters(input): Parameters<VerifyGpgInput>) -> String {
        let req = crate::api::types::VerifyGpg {
            display_id: input.display_id.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            passphrase: input.passphrase.clone(),
            signature: input.signature.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
        };
        match self.client.verify_gpg(&req).await {
            Ok(result) => format::format_verify_gpg(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "verify_jwt_with_classic_key operation")]
    async fn verify_jwt_with_classic_key(&self, Parameters(input): Parameters<VerifyJwtWithClassicKeyInput>) -> String {
        let req = crate::api::types::VerifyJwtWithClassicKey {
            display_id: input.display_id.clone(),
            json: input.json.clone(),
            jwt: input.jwt.clone(),
            required_claims: input.required_claims.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.verify_jwt_with_classic_key(&req).await {
            Ok(result) => format::format_verify_jwt_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "verify_pkcs1 operation")]
    async fn verify_pkcs1(&self, Parameters(input): Parameters<VerifyPkcs1Input>) -> String {
        let req = crate::api::types::VerifyPkcs1 {
            display_id: input.display_id.clone(),
            hash_function: input.hash_function.clone(),
            input_format: input.input_format.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            message: input.message.clone(),
            prehashed: input.prehashed.clone(),
            signature: input.signature.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.verify_pkcs1(&req).await {
            Ok(result) => format::format_verify_pkcs1(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "verify_pki_cert_with_classic_key operation")]
    async fn verify_pki_cert_with_classic_key(&self, Parameters(input): Parameters<VerifyPkiCertWithClassicKeyInput>) -> String {
        let req = crate::api::types::VerifyPkiCertWithClassicKey {
            display_id: input.display_id.clone(),
            json: input.json.clone(),
            pki_cert: input.pki_cert.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.verify_pki_cert_with_classic_key(&req).await {
            Ok(result) => format::format_verify_pki_cert_with_classic_key(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

    #[tool(description = "verify_rsa_ssa_pss operation")]
    async fn verify_rsa_ssa_pss(&self, Parameters(input): Parameters<VerifyRsaSsaPssInput>) -> String {
        let req = crate::api::types::VerifyRsaSsaPss {
            display_id: input.display_id.clone(),
            hash_function: input.hash_function.clone(),
            item_id: input.item_id.clone(),
            json: input.json.clone(),
            key_name: input.key_name.clone(),
            message: input.message.clone(),
            prehashed: input.prehashed.clone(),
            signature: input.signature.clone(),
            token: input.token.clone(),
            uid_token: input.uid_token.clone(),
            version: input.version.clone(),
        };
        match self.client.verify_rsa_ssa_pss(&req).await {
            Ok(result) => format::format_verify_rsa_ssa_pss(&result),
            Err(e) => format!("Error: {e}"),
        }
    }

}

#[tool_handler]
impl ServerHandler for AkeylessMcpMcp {
    fn get_info(&self) -> ServerInfo {
        ServerInfo {
            instructions: Some(
                "The purpose of this application is to provide access to Akeyless API."
                    .into(),
            ),
            capabilities: ServerCapabilities::builder().enable_tools().build(),
            ..Default::default()
        }
    }
}

// -- Entry point --

pub async fn run() -> std::result::Result<(), Box<dyn std::error::Error>> {
    let server = AkeylessMcpMcp::new()?.serve(stdio()).await?;
    server.waiting().await?;
    Ok(())
}