infisical-sdk 2.3.8 → 3.0.0

data/lib/schemas.rb

@@ -1,1728 +0,0 @@
-# This code may look unusually verbose for Ruby (and it is), but
-# it performs some subtle and complex validation of JSON data.
-#
-# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do:
-#
-#   client_settings = ClientSettings.from_json! "{…}"
-#   puts client_settings.auth&.access_token.nil?
-#
-#   command = Command.from_json! "{…}"
-#   puts command.aws_iam_auth_login&.identity_id
-#
-#   response_for_access_token_success_response = ResponseForAccessTokenSuccessResponse.from_json! "{…}"
-#   puts response_for_access_token_success_response.data&.access_token
-#
-#   response_for_create_secret_response = ResponseForCreateSecretResponse.from_json! "{…}"
-#   puts response_for_create_secret_response.data&.secret.environment
-#
-#   response_for_create_symmetric_key_response = ResponseForCreateSymmetricKeyResponse.from_json! "{…}"
-#   puts response_for_create_symmetric_key_response.data&.key
-#
-#   response_for_decrypt_symmetric_response = ResponseForDecryptSymmetricResponse.from_json! "{…}"
-#   puts response_for_decrypt_symmetric_response.data&.decrypted
-#
-#   response_for_delete_secret_response = ResponseForDeleteSecretResponse.from_json! "{…}"
-#   puts response_for_delete_secret_response.data&.secret.environment
-#
-#   response_for_encrypt_symmetric_response = ResponseForEncryptSymmetricResponse.from_json! "{…}"
-#   puts response_for_encrypt_symmetric_response.data&.ciphertext
-#
-#   response_for_get_secret_response = ResponseForGetSecretResponse.from_json! "{…}"
-#   puts response_for_get_secret_response.data&.secret.environment
-#
-#   response_for_list_secrets_response = ResponseForListSecretsResponse.from_json! "{…}"
-#   puts response_for_list_secrets_response.data&.secrets.first.environment
-#
-#   response_for_update_secret_response = ResponseForUpdateSecretResponse.from_json! "{…}"
-#   puts response_for_update_secret_response.data&.secret.environment
-#
-# If from_json! succeeds, the value returned matches the schema.
-
-require 'json'
-require 'dry-types'
-require 'dry-struct'
-
-module Types
-  include Dry.Types(default: :nominal)
-
-  Integer = Strict::Integer
-  Nil     = Strict::Nil
-  Bool    = Strict::Bool
-  Hash    = Strict::Hash
-  String  = Strict::String
-end
-
-class AWSIamAuthMethod < Dry::Struct
-
-  # The Infisical Identity ID that you want to authenticate to Infisical with.
-  attribute :identity_id, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id: d.fetch("identityId"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId" => identity_id,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class AzureAuthMethod < Dry::Struct
-
-  # The Infisical Identity ID that you want to authenticate to Infisical with.
-  attribute :identity_id, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id: d.fetch("identityId"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId" => identity_id,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class GCPIamAuthMethod < Dry::Struct
-  attribute :identity_id, Types::String
-
-  # The path to the GCP Service Account key file.
-  #
-  # You can generate this key file by going to the GCP Console -> IAM & Admin -> Service
-  # Accounts -> *Select your service account* -> Keys tab -> Add key.
-  # Note: The key must be in JSON format.
-  attribute :service_account_key_file_path, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id:                   d.fetch("identityId"),
-      service_account_key_file_path: d.fetch("serviceAccountKeyFilePath"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId"                => identity_id,
-      "serviceAccountKeyFilePath" => service_account_key_file_path,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class GCPIDTokenAuthMethod < Dry::Struct
-  attribute :identity_id, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id: d.fetch("identityId"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId" => identity_id,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class KubernetesAuthMethod < Dry::Struct
-
-  # The Infisical Identity ID that you want to authenticate to Infisical with.
-  attribute :identity_id, Types::String
-
-  # The path to the Kubernetes Service Account token file.
-  #
-  # If no path is provided, it will default to
-  # /var/run/secrets/kubernetes.io/serviceaccount/token.
-  attribute :service_account_token_path, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id:                d.fetch("identityId"),
-      service_account_token_path: d["serviceAccountTokenPath"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId"              => identity_id,
-      "serviceAccountTokenPath" => service_account_token_path,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class UniversalAuthMethod < Dry::Struct
-  attribute :client_id,     Types::String
-  attribute :client_secret, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      client_id:     d.fetch("clientId"),
-      client_secret: d.fetch("clientSecret"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "clientId"     => client_id,
-      "clientSecret" => client_secret,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-# Configure the authentication method to use.
-#
-# Make sure to only set one one method at a time to avoid conflicts and unexpected behavior.
-class AuthenticationOptions < Dry::Struct
-  attribute :access_token,   Types::String.optional.optional
-  attribute :aws_iam,        AWSIamAuthMethod.optional.optional
-  attribute :azure,          AzureAuthMethod.optional.optional
-  attribute :gcp_iam,        GCPIamAuthMethod.optional.optional
-  attribute :gcp_id_token,   GCPIDTokenAuthMethod.optional.optional
-  attribute :kubernetes,     KubernetesAuthMethod.optional.optional
-  attribute :universal_auth, UniversalAuthMethod.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      access_token:   d["accessToken"],
-      aws_iam:        d["awsIam"] ? AWSIamAuthMethod.from_dynamic!(d["awsIam"]) : nil,
-      azure:          d["azure"] ? AzureAuthMethod.from_dynamic!(d["azure"]) : nil,
-      gcp_iam:        d["gcpIam"] ? GCPIamAuthMethod.from_dynamic!(d["gcpIam"]) : nil,
-      gcp_id_token:   d["gcpIdToken"] ? GCPIDTokenAuthMethod.from_dynamic!(d["gcpIdToken"]) : nil,
-      kubernetes:     d["kubernetes"] ? KubernetesAuthMethod.from_dynamic!(d["kubernetes"]) : nil,
-      universal_auth: d["universalAuth"] ? UniversalAuthMethod.from_dynamic!(d["universalAuth"]) : nil,
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "accessToken"   => access_token,
-      "awsIam"        => aws_iam&.to_dynamic,
-      "azure"         => azure&.to_dynamic,
-      "gcpIam"        => gcp_iam&.to_dynamic,
-      "gcpIdToken"    => gcp_id_token&.to_dynamic,
-      "kubernetes"    => kubernetes&.to_dynamic,
-      "universalAuth" => universal_auth&.to_dynamic,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ClientSettings < Dry::Struct
-
-  # **DEPRECATED**: The access token field is deprecated. Please use the new auth object
-  # field instead.
-  attribute :access_token, Types::String.optional.optional
-
-  # Configure the authentication method to use.
-  #
-  # Make sure to only set one one method at a time to avoid conflicts and unexpected behavior.
-  attribute :auth, AuthenticationOptions.optional
-
-  # cacheTTL controls how often the cache should refresh, default is 300 seconds. Set to 0 to
-  # disable the cache.
-  attribute :cache_ttl, Types::Integer.optional.optional
-
-  # **DEPRECATED**: The client secret field is deprecated. Please use the new auth object
-  # field instead.
-  attribute :client_id, Types::String.optional.optional
-
-  # **DEPRECATED**: The client secret field is deprecated. Please use the new auth object
-  # field instead.
-  attribute :client_secret, Types::String.optional.optional
-
-  # The URL of the site to connect to. Defaults to "https://app.infisical.com".
-  attribute :site_url, Types::String.optional.optional
-
-  # The SSL certificate path is an optional field that allows you to specify a custom SSL
-  # certificate to use for requests made to Infisical.
-  # This option can be substituted with the `INFISICAL_SSL_CERTIFICATE` environment variable,
-  # which should contain the certificate as a string, not the path.
-  attribute :ssl_certificate_path, Types::String.optional.optional
-
-  attribute :user_agent, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      access_token:         d["accessToken"],
-      auth:                 d["auth"] ? AuthenticationOptions.from_dynamic!(d["auth"]) : nil,
-      cache_ttl:            d["cacheTtl"],
-      client_id:            d["clientId"],
-      client_secret:        d["clientSecret"],
-      site_url:             d["siteUrl"],
-      ssl_certificate_path: d["sslCertificatePath"],
-      user_agent:           d["userAgent"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "accessToken"        => access_token,
-      "auth"               => auth&.to_dynamic,
-      "cacheTtl"           => cache_ttl,
-      "clientId"           => client_id,
-      "clientSecret"       => client_secret,
-      "siteUrl"            => site_url,
-      "sslCertificatePath" => ssl_certificate_path,
-      "userAgent"          => user_agent,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class AwsIamAuthLoginClass < Dry::Struct
-
-  # The Infisical Identity ID that you want to authenticate to Infisical with.
-  attribute :identity_id, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id: d.fetch("identityId"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId" => identity_id,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class AzureAuthLoginClass < Dry::Struct
-
-  # The Infisical Identity ID that you want to authenticate to Infisical with.
-  attribute :identity_id, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id: d.fetch("identityId"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId" => identity_id,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class CreateSecretOptions < Dry::Struct
-  attribute :environment,                Types::String
-  attribute :path,                       Types::String.optional.optional
-  attribute :project_id,                 Types::String
-  attribute :secret_comment,             Types::String.optional.optional
-  attribute :secret_name,                Types::String
-  attribute :secret_value,               Types::String
-  attribute :skip_multiline_encoding,    Types::Bool.optional.optional
-  attribute :create_secret_options_type, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:                d.fetch("environment"),
-      path:                       d["path"],
-      project_id:                 d.fetch("projectId"),
-      secret_comment:             d["secretComment"],
-      secret_name:                d.fetch("secretName"),
-      secret_value:               d.fetch("secretValue"),
-      skip_multiline_encoding:    d["skipMultilineEncoding"],
-      create_secret_options_type: d["type"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"           => environment,
-      "path"                  => path,
-      "projectId"             => project_id,
-      "secretComment"         => secret_comment,
-      "secretName"            => secret_name,
-      "secretValue"           => secret_value,
-      "skipMultilineEncoding" => skip_multiline_encoding,
-      "type"                  => create_secret_options_type,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ArbitraryOptions < Dry::Struct
-  attribute :data, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data: d.fetch("data"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data" => data,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class DecryptSymmetricOptions < Dry::Struct
-  attribute :ciphertext, Types::String
-  attribute :iv,         Types::String
-  attribute :key,        Types::String
-  attribute :tag,        Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      ciphertext: d.fetch("ciphertext"),
-      iv:         d.fetch("iv"),
-      key:        d.fetch("key"),
-      tag:        d.fetch("tag"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "ciphertext" => ciphertext,
-      "iv"         => iv,
-      "key"        => key,
-      "tag"        => tag,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class DeleteSecretOptions < Dry::Struct
-  attribute :environment,                Types::String
-  attribute :path,                       Types::String.optional.optional
-  attribute :project_id,                 Types::String
-  attribute :secret_name,                Types::String
-  attribute :delete_secret_options_type, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:                d.fetch("environment"),
-      path:                       d["path"],
-      project_id:                 d.fetch("projectId"),
-      secret_name:                d.fetch("secretName"),
-      delete_secret_options_type: d["type"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment" => environment,
-      "path"        => path,
-      "projectId"   => project_id,
-      "secretName"  => secret_name,
-      "type"        => delete_secret_options_type,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class EncryptSymmetricOptions < Dry::Struct
-  attribute :key,       Types::String
-  attribute :plaintext, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      key:       d.fetch("key"),
-      plaintext: d.fetch("plaintext"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "key"       => key,
-      "plaintext" => plaintext,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class GcpIamAuthLoginClass < Dry::Struct
-  attribute :identity_id, Types::String
-
-  # The path to the GCP Service Account key file.
-  #
-  # You can generate this key file by going to the GCP Console -> IAM & Admin -> Service
-  # Accounts -> *Select your service account* -> Keys tab -> Add key.
-  # Note: The key must be in JSON format.
-  attribute :service_account_key_file_path, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id:                   d.fetch("identityId"),
-      service_account_key_file_path: d.fetch("serviceAccountKeyFilePath"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId"                => identity_id,
-      "serviceAccountKeyFilePath" => service_account_key_file_path,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class GcpIDTokenAuthLoginClass < Dry::Struct
-  attribute :identity_id, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id: d.fetch("identityId"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId" => identity_id,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class GetSecretOptions < Dry::Struct
-  attribute :environment,              Types::String
-  attribute :expand_secret_references, Types::Bool.optional.optional
-  attribute :include_imports,          Types::Bool.optional.optional
-  attribute :path,                     Types::String.optional.optional
-  attribute :project_id,               Types::String
-  attribute :secret_name,              Types::String
-  attribute :get_secret_options_type,  Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:              d.fetch("environment"),
-      expand_secret_references: d["expandSecretReferences"],
-      include_imports:          d["includeImports"],
-      path:                     d["path"],
-      project_id:               d.fetch("projectId"),
-      secret_name:              d.fetch("secretName"),
-      get_secret_options_type:  d["type"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"            => environment,
-      "expandSecretReferences" => expand_secret_references,
-      "includeImports"         => include_imports,
-      "path"                   => path,
-      "projectId"              => project_id,
-      "secretName"             => secret_name,
-      "type"                   => get_secret_options_type,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class KubernetesAuthLoginClass < Dry::Struct
-
-  # The Infisical Identity ID that you want to authenticate to Infisical with.
-  attribute :identity_id, Types::String
-
-  # The path to the Kubernetes Service Account token file.
-  #
-  # If no path is provided, it will default to
-  # /var/run/secrets/kubernetes.io/serviceaccount/token.
-  attribute :service_account_token_path, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      identity_id:                d.fetch("identityId"),
-      service_account_token_path: d["serviceAccountTokenPath"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "identityId"              => identity_id,
-      "serviceAccountTokenPath" => service_account_token_path,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ListSecretsOptions < Dry::Struct
-  attribute :attach_to_process_env,    Types::Bool.optional.optional
-  attribute :environment,              Types::String
-  attribute :expand_secret_references, Types::Bool.optional.optional
-  attribute :include_imports,          Types::Bool.optional.optional
-  attribute :path,                     Types::String.optional.optional
-  attribute :project_id,               Types::String
-  attribute :recursive,                Types::Bool.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      attach_to_process_env:    d["attachToProcessEnv"],
-      environment:              d.fetch("environment"),
-      expand_secret_references: d["expandSecretReferences"],
-      include_imports:          d["includeImports"],
-      path:                     d["path"],
-      project_id:               d.fetch("projectId"),
-      recursive:                d["recursive"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "attachToProcessEnv"     => attach_to_process_env,
-      "environment"            => environment,
-      "expandSecretReferences" => expand_secret_references,
-      "includeImports"         => include_imports,
-      "path"                   => path,
-      "projectId"              => project_id,
-      "recursive"              => recursive,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class UniversalAuthLoginClass < Dry::Struct
-  attribute :client_id,     Types::String
-  attribute :client_secret, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      client_id:     d.fetch("clientId"),
-      client_secret: d.fetch("clientSecret"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "clientId"     => client_id,
-      "clientSecret" => client_secret,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class UpdateSecretOptions < Dry::Struct
-  attribute :environment,                Types::String
-  attribute :path,                       Types::String.optional.optional
-  attribute :project_id,                 Types::String
-  attribute :secret_name,                Types::String
-  attribute :secret_value,               Types::String
-  attribute :skip_multiline_encoding,    Types::Bool.optional.optional
-  attribute :update_secret_options_type, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:                d.fetch("environment"),
-      path:                       d["path"],
-      project_id:                 d.fetch("projectId"),
-      secret_name:                d.fetch("secretName"),
-      secret_value:               d.fetch("secretValue"),
-      skip_multiline_encoding:    d["skipMultilineEncoding"],
-      update_secret_options_type: d["type"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"           => environment,
-      "path"                  => path,
-      "projectId"             => project_id,
-      "secretName"            => secret_name,
-      "secretValue"           => secret_value,
-      "skipMultilineEncoding" => skip_multiline_encoding,
-      "type"                  => update_secret_options_type,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class Command < Dry::Struct
-  attribute :get_secret,              GetSecretOptions.optional
-  attribute :list_secrets,            ListSecretsOptions.optional
-  attribute :create_secret,           CreateSecretOptions.optional
-  attribute :update_secret,           UpdateSecretOptions.optional
-  attribute :delete_secret,           DeleteSecretOptions.optional
-  attribute :create_symmetric_key,    ArbitraryOptions.optional
-  attribute :encrypt_symmetric,       EncryptSymmetricOptions.optional
-  attribute :decrypt_symmetric,       DecryptSymmetricOptions.optional
-  attribute :universal_auth_login,    UniversalAuthLoginClass.optional
-  attribute :kubernetes_auth_login,   KubernetesAuthLoginClass.optional
-  attribute :azure_auth_login,        AzureAuthLoginClass.optional
-  attribute :gcp_id_token_auth_login, GcpIDTokenAuthLoginClass.optional
-  attribute :gcp_iam_auth_login,      GcpIamAuthLoginClass.optional
-  attribute :aws_iam_auth_login,      AwsIamAuthLoginClass.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      get_secret:              d["getSecret"] ? GetSecretOptions.from_dynamic!(d["getSecret"]) : nil,
-      list_secrets:            d["listSecrets"] ? ListSecretsOptions.from_dynamic!(d["listSecrets"]) : nil,
-      create_secret:           d["createSecret"] ? CreateSecretOptions.from_dynamic!(d["createSecret"]) : nil,
-      update_secret:           d["updateSecret"] ? UpdateSecretOptions.from_dynamic!(d["updateSecret"]) : nil,
-      delete_secret:           d["deleteSecret"] ? DeleteSecretOptions.from_dynamic!(d["deleteSecret"]) : nil,
-      create_symmetric_key:    d["createSymmetricKey"] ? ArbitraryOptions.from_dynamic!(d["createSymmetricKey"]) : nil,
-      encrypt_symmetric:       d["encryptSymmetric"] ? EncryptSymmetricOptions.from_dynamic!(d["encryptSymmetric"]) : nil,
-      decrypt_symmetric:       d["decryptSymmetric"] ? DecryptSymmetricOptions.from_dynamic!(d["decryptSymmetric"]) : nil,
-      universal_auth_login:    d["universalAuthLogin"] ? UniversalAuthLoginClass.from_dynamic!(d["universalAuthLogin"]) : nil,
-      kubernetes_auth_login:   d["kubernetesAuthLogin"] ? KubernetesAuthLoginClass.from_dynamic!(d["kubernetesAuthLogin"]) : nil,
-      azure_auth_login:        d["azureAuthLogin"] ? AzureAuthLoginClass.from_dynamic!(d["azureAuthLogin"]) : nil,
-      gcp_id_token_auth_login: d["gcpIdTokenAuthLogin"] ? GcpIDTokenAuthLoginClass.from_dynamic!(d["gcpIdTokenAuthLogin"]) : nil,
-      gcp_iam_auth_login:      d["gcpIamAuthLogin"] ? GcpIamAuthLoginClass.from_dynamic!(d["gcpIamAuthLogin"]) : nil,
-      aws_iam_auth_login:      d["awsIamAuthLogin"] ? AwsIamAuthLoginClass.from_dynamic!(d["awsIamAuthLogin"]) : nil,
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "getSecret"           => get_secret&.to_dynamic,
-      "listSecrets"         => list_secrets&.to_dynamic,
-      "createSecret"        => create_secret&.to_dynamic,
-      "updateSecret"        => update_secret&.to_dynamic,
-      "deleteSecret"        => delete_secret&.to_dynamic,
-      "createSymmetricKey"  => create_symmetric_key&.to_dynamic,
-      "encryptSymmetric"    => encrypt_symmetric&.to_dynamic,
-      "decryptSymmetric"    => decrypt_symmetric&.to_dynamic,
-      "universalAuthLogin"  => universal_auth_login&.to_dynamic,
-      "kubernetesAuthLogin" => kubernetes_auth_login&.to_dynamic,
-      "azureAuthLogin"      => azure_auth_login&.to_dynamic,
-      "gcpIdTokenAuthLogin" => gcp_id_token_auth_login&.to_dynamic,
-      "gcpIamAuthLogin"     => gcp_iam_auth_login&.to_dynamic,
-      "awsIamAuthLogin"     => aws_iam_auth_login&.to_dynamic,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class AccessTokenSuccessResponse < Dry::Struct
-  attribute :access_token,         Types::String
-  attribute :access_token_max_ttl, Types::Integer
-  attribute :expires_in,           Types::Integer
-  attribute :token_type,           Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      access_token:         d.fetch("accessToken"),
-      access_token_max_ttl: d.fetch("accessTokenMaxTTL"),
-      expires_in:           d.fetch("expiresIn"),
-      token_type:           d.fetch("tokenType"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "accessToken"       => access_token,
-      "accessTokenMaxTTL" => access_token_max_ttl,
-      "expiresIn"         => expires_in,
-      "tokenType"         => token_type,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForAccessTokenSuccessResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, AccessTokenSuccessResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? AccessTokenSuccessResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class CreateSecretResponseSecret < Dry::Struct
-  attribute :environment,    Types::String
-  attribute :is_fallback,    Types::Bool.optional
-  attribute :secret_comment, Types::String
-  attribute :secret_key,     Types::String
-
-  # The path of the secret.
-  #
-  # Note that this will only be present when using the `list secrets` method.
-  attribute :secret_path, Types::String.optional.optional
-
-  attribute :secret_value, Types::String
-  attribute :secret_type,  Types::String
-  attribute :version,      Types::Integer
-  attribute :workspace,    Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:    d.fetch("environment"),
-      is_fallback:    d["isFallback"],
-      secret_comment: d.fetch("secretComment"),
-      secret_key:     d.fetch("secretKey"),
-      secret_path:    d["secretPath"],
-      secret_value:   d.fetch("secretValue"),
-      secret_type:    d.fetch("type"),
-      version:        d.fetch("version"),
-      workspace:      d.fetch("workspace"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"   => environment,
-      "isFallback"    => is_fallback,
-      "secretComment" => secret_comment,
-      "secretKey"     => secret_key,
-      "secretPath"    => secret_path,
-      "secretValue"   => secret_value,
-      "type"          => secret_type,
-      "version"       => version,
-      "workspace"     => workspace,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class CreateSecretResponse < Dry::Struct
-  attribute :secret, CreateSecretResponseSecret
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      secret: CreateSecretResponseSecret.from_dynamic!(d.fetch("secret")),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "secret" => secret.to_dynamic,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForCreateSecretResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, CreateSecretResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? CreateSecretResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class CreateSymmetricKeyResponse < Dry::Struct
-  attribute :key, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      key: d.fetch("key"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "key" => key,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForCreateSymmetricKeyResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, CreateSymmetricKeyResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? CreateSymmetricKeyResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class DecryptSymmetricResponse < Dry::Struct
-  attribute :decrypted, Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      decrypted: d.fetch("decrypted"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "decrypted" => decrypted,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForDecryptSymmetricResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, DecryptSymmetricResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? DecryptSymmetricResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class DeleteSecretResponseSecret < Dry::Struct
-  attribute :environment,    Types::String
-  attribute :is_fallback,    Types::Bool.optional
-  attribute :secret_comment, Types::String
-  attribute :secret_key,     Types::String
-
-  # The path of the secret.
-  #
-  # Note that this will only be present when using the `list secrets` method.
-  attribute :secret_path, Types::String.optional.optional
-
-  attribute :secret_value, Types::String
-  attribute :secret_type,  Types::String
-  attribute :version,      Types::Integer
-  attribute :workspace,    Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:    d.fetch("environment"),
-      is_fallback:    d["isFallback"],
-      secret_comment: d.fetch("secretComment"),
-      secret_key:     d.fetch("secretKey"),
-      secret_path:    d["secretPath"],
-      secret_value:   d.fetch("secretValue"),
-      secret_type:    d.fetch("type"),
-      version:        d.fetch("version"),
-      workspace:      d.fetch("workspace"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"   => environment,
-      "isFallback"    => is_fallback,
-      "secretComment" => secret_comment,
-      "secretKey"     => secret_key,
-      "secretPath"    => secret_path,
-      "secretValue"   => secret_value,
-      "type"          => secret_type,
-      "version"       => version,
-      "workspace"     => workspace,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class DeleteSecretResponse < Dry::Struct
-  attribute :secret, DeleteSecretResponseSecret
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      secret: DeleteSecretResponseSecret.from_dynamic!(d.fetch("secret")),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "secret" => secret.to_dynamic,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForDeleteSecretResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, DeleteSecretResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? DeleteSecretResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class EncryptSymmetricResponse < Dry::Struct
-  attribute :ciphertext, Types::String
-  attribute :iv,         Types::String
-  attribute :tag,        Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      ciphertext: d.fetch("ciphertext"),
-      iv:         d.fetch("iv"),
-      tag:        d.fetch("tag"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "ciphertext" => ciphertext,
-      "iv"         => iv,
-      "tag"        => tag,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForEncryptSymmetricResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, EncryptSymmetricResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? EncryptSymmetricResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class GetSecretResponseSecret < Dry::Struct
-  attribute :environment,    Types::String
-  attribute :is_fallback,    Types::Bool.optional
-  attribute :secret_comment, Types::String
-  attribute :secret_key,     Types::String
-
-  # The path of the secret.
-  #
-  # Note that this will only be present when using the `list secrets` method.
-  attribute :secret_path, Types::String.optional.optional
-
-  attribute :secret_value, Types::String
-  attribute :secret_type,  Types::String
-  attribute :version,      Types::Integer
-  attribute :workspace,    Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:    d.fetch("environment"),
-      is_fallback:    d["isFallback"],
-      secret_comment: d.fetch("secretComment"),
-      secret_key:     d.fetch("secretKey"),
-      secret_path:    d["secretPath"],
-      secret_value:   d.fetch("secretValue"),
-      secret_type:    d.fetch("type"),
-      version:        d.fetch("version"),
-      workspace:      d.fetch("workspace"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"   => environment,
-      "isFallback"    => is_fallback,
-      "secretComment" => secret_comment,
-      "secretKey"     => secret_key,
-      "secretPath"    => secret_path,
-      "secretValue"   => secret_value,
-      "type"          => secret_type,
-      "version"       => version,
-      "workspace"     => workspace,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class GetSecretResponse < Dry::Struct
-  attribute :secret, GetSecretResponseSecret
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      secret: GetSecretResponseSecret.from_dynamic!(d.fetch("secret")),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "secret" => secret.to_dynamic,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForGetSecretResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, GetSecretResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? GetSecretResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class SecretElement < Dry::Struct
-  attribute :environment,    Types::String
-  attribute :is_fallback,    Types::Bool.optional
-  attribute :secret_comment, Types::String
-  attribute :secret_key,     Types::String
-
-  # The path of the secret.
-  #
-  # Note that this will only be present when using the `list secrets` method.
-  attribute :secret_path, Types::String.optional.optional
-
-  attribute :secret_value, Types::String
-  attribute :secret_type,  Types::String
-  attribute :version,      Types::Integer
-  attribute :workspace,    Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:    d.fetch("environment"),
-      is_fallback:    d["isFallback"],
-      secret_comment: d.fetch("secretComment"),
-      secret_key:     d.fetch("secretKey"),
-      secret_path:    d["secretPath"],
-      secret_value:   d.fetch("secretValue"),
-      secret_type:    d.fetch("type"),
-      version:        d.fetch("version"),
-      workspace:      d.fetch("workspace"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"   => environment,
-      "isFallback"    => is_fallback,
-      "secretComment" => secret_comment,
-      "secretKey"     => secret_key,
-      "secretPath"    => secret_path,
-      "secretValue"   => secret_value,
-      "type"          => secret_type,
-      "version"       => version,
-      "workspace"     => workspace,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ListSecretsResponse < Dry::Struct
-  attribute :secrets, Types.Array(SecretElement)
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      secrets: d.fetch("secrets").map { |x| SecretElement.from_dynamic!(x) },
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "secrets" => secrets.map { |x| x.to_dynamic },
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForListSecretsResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, ListSecretsResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? ListSecretsResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class UpdateSecretResponseSecret < Dry::Struct
-  attribute :environment,    Types::String
-  attribute :is_fallback,    Types::Bool.optional
-  attribute :secret_comment, Types::String
-  attribute :secret_key,     Types::String
-
-  # The path of the secret.
-  #
-  # Note that this will only be present when using the `list secrets` method.
-  attribute :secret_path, Types::String.optional.optional
-
-  attribute :secret_value, Types::String
-  attribute :secret_type,  Types::String
-  attribute :version,      Types::Integer
-  attribute :workspace,    Types::String
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      environment:    d.fetch("environment"),
-      is_fallback:    d["isFallback"],
-      secret_comment: d.fetch("secretComment"),
-      secret_key:     d.fetch("secretKey"),
-      secret_path:    d["secretPath"],
-      secret_value:   d.fetch("secretValue"),
-      secret_type:    d.fetch("type"),
-      version:        d.fetch("version"),
-      workspace:      d.fetch("workspace"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "environment"   => environment,
-      "isFallback"    => is_fallback,
-      "secretComment" => secret_comment,
-      "secretKey"     => secret_key,
-      "secretPath"    => secret_path,
-      "secretValue"   => secret_value,
-      "type"          => secret_type,
-      "version"       => version,
-      "workspace"     => workspace,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class UpdateSecretResponse < Dry::Struct
-  attribute :secret, UpdateSecretResponseSecret
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      secret: UpdateSecretResponseSecret.from_dynamic!(d.fetch("secret")),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "secret" => secret.to_dynamic,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class ResponseForUpdateSecretResponse < Dry::Struct
-
-  # The response data. Populated if `success` is true.
-  attribute :data, UpdateSecretResponse.optional.optional
-
-  # A message for any error that may occur. Populated if `success` is false.
-  attribute :error_message, Types::String.optional.optional
-
-  # Whether or not the SDK request succeeded.
-  attribute :success, Types::Bool
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:          d["data"] ? UpdateSecretResponse.from_dynamic!(d["data"]) : nil,
-      error_message: d["errorMessage"],
-      success:       d.fetch("success"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"         => data&.to_dynamic,
-      "errorMessage" => error_message,
-      "success"      => success,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-