infisical-sdk 0.0.1

data/lib/schemas.rb

@@ -0,0 +1,1717 @@
+# 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
+
+  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"],
+      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,
+      "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 :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"),
+      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,
+      "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
+