ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/network/f5/bigip_snat_pool.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether the SNAT pool should exist or not.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition

data/lib/ansible/ruby/modules/generated/network/f5/bigip_snmp.rb

@@ -17,15 +17,15 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] When C(enabled), ensures that the system sends a trap whenever the SNMP agent starts running or stops running. This is usually enabled by default on a BIG-IP.
         attribute :agent_status_traps
-        validates :agent_status_traps, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :agent_status_traps, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] When C(enabled), ensures that the system sends authentication warning traps to the trap destinations. This is usually disabled by default on a BIG-IP.
         attribute :agent_authentication_traps
-        validates :agent_authentication_traps, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :agent_authentication_traps, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] When C(enabled), ensures that the system sends device warning traps to the trap destinations. This is usually enabled by default on a BIG-IP.
         attribute :device_warning_traps
-        validates :device_warning_traps, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :device_warning_traps, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [String, nil] Specifies the description of this system's physical location.
         attribute :location

data/lib/ansible/ruby/modules/generated/network/f5/bigip_snmp_community.rb

@@ -10,11 +10,11 @@ module Ansible
       class Bigip_snmp_community < Base
         # @return [:present, :absent, nil] When C(present), ensures that the address list and entries exists.,When C(absent), ensures the address list is removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [:v1, :v2c, :v3, nil] Specifies to which Simple Network Management Protocol (SNMP) version the trap destination applies.
         attribute :version
-        validates :version, inclusion: {:in=>[:v1, :v2c, :v3], :message=>"%{value} needs to be :v1, :v2c, :v3"}, allow_nil: true
+        validates :version, expression_inclusion: {:in=>[:v1, :v2c, :v3], :message=>"%{value} needs to be :v1, :v2c, :v3"}, allow_nil: true
 
         # @return [String, nil] Name that identifies the SNMP community.,When C(version) is C(v1) or C(v2c), this parameter is required.,The name C(public) is a reserved name on the BIG-IP. This module handles that name differently than others. Functionally, you should not see a difference however.
         attribute :name
@@ -36,11 +36,11 @@ module Ansible
 
         # @return [:ro, :rw, :"read-only", :"read-write", nil] Specifies the user's access level to the MIB.,When creating a new community, if this parameter is not specified, the default is C(ro).,When C(ro), specifies that the user can view the MIB, but cannot modify the MIB.,When C(rw), specifies that the user can view and modify the MIB.
         attribute :access
-        validates :access, inclusion: {:in=>[:ro, :rw, :"read-only", :"read-write"], :message=>"%{value} needs to be :ro, :rw, :\"read-only\", :\"read-write\""}, allow_nil: true
+        validates :access, expression_inclusion: {:in=>[:ro, :rw, :"read-only", :"read-write"], :message=>"%{value} needs to be :ro, :rw, :\"read-only\", :\"read-write\""}, allow_nil: true
 
         # @return [4, 6, nil] Specifies whether the record applies to IPv4 or IPv6 addresses.,When creating a new community, if this value is not specified, the default of C(4) will be used.,This parameter is only relevant when C(version) is C(v1), or C(v2c). If C(version) is something else, this parameter is ignored.
         attribute :ip_version
-        validates :ip_version, inclusion: {:in=>[4, 6], :message=>"%{value} needs to be 4, 6"}, allow_nil: true
+        validates :ip_version, expression_inclusion: {:in=>[4, 6], :message=>"%{value} needs to be 4, 6"}, allow_nil: true
 
         # @return [String, nil] Specifies the name of the user for whom you want to grant access to the SNMP v3 MIB.,This parameter is only relevant when C(version) is C(v3). If C(version) is something else, this parameter is ignored.,When creating a new SNMP C(v3) community, this parameter is required.,This parameter cannot be changed once it has been set.
         attribute :snmp_username
@@ -48,7 +48,7 @@ module Ansible
 
         # @return [:md5, :sha, :none, nil] Specifies the authentication method for the user.,When C(md5), specifies that the system uses the MD5 algorithm to authenticate the user.,When C(sha), specifies that the secure hash algorithm (SHA) to authenticate the user.,When C(none), specifies that user does not require authentication.,When creating a new SNMP C(v3) community, if this parameter is not specified, the default of C(sha) will be used.
         attribute :snmp_auth_protocol
-        validates :snmp_auth_protocol, inclusion: {:in=>[:md5, :sha, :none], :message=>"%{value} needs to be :md5, :sha, :none"}, allow_nil: true
+        validates :snmp_auth_protocol, expression_inclusion: {:in=>[:md5, :sha, :none], :message=>"%{value} needs to be :md5, :sha, :none"}, allow_nil: true
 
         # @return [String, nil] Specifies the password for the user.,When creating a new SNMP C(v3) community, this parameter is required.,This value must be at least 8 characters long.
         attribute :snmp_auth_password
@@ -56,7 +56,7 @@ module Ansible
 
         # @return [:aes, :des, :none, nil] Specifies the encryption protocol.,When C(aes), specifies that the system encrypts the user information using AES (Advanced Encryption Standard).,When C(des), specifies that the system encrypts the user information using DES (Data Encryption Standard).,When C(none), specifies that the system does not encrypt the user information.,When creating a new SNMP C(v3) community, if this parameter is not specified, the default of C(aes) will be used.
         attribute :snmp_privacy_protocol
-        validates :snmp_privacy_protocol, inclusion: {:in=>[:aes, :des, :none], :message=>"%{value} needs to be :aes, :des, :none"}, allow_nil: true
+        validates :snmp_privacy_protocol, expression_inclusion: {:in=>[:aes, :des, :none], :message=>"%{value} needs to be :aes, :des, :none"}, allow_nil: true
 
         # @return [String, nil] Specifies the password for the user.,When creating a new SNMP C(v3) community, this parameter is required.,This value must be at least 8 characters long.
         attribute :snmp_privacy_password
@@ -64,7 +64,7 @@ module Ansible
 
         # @return [:always, :on_create, nil] C(always) will allow to update passwords if the user chooses to do so. C(on_create) will only set the password for newly created resources.
         attribute :update_password
-        validates :update_password, inclusion: {:in=>[:always, :on_create], :message=>"%{value} needs to be :always, :on_create"}, allow_nil: true
+        validates :update_password, expression_inclusion: {:in=>[:always, :on_create], :message=>"%{value} needs to be :always, :on_create"}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition

data/lib/ansible/ruby/modules/generated/network/f5/bigip_snmp_trap.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [1, :"2c", nil] Specifies to which Simple Network Management Protocol (SNMP) version the trap destination applies.
         attribute :snmp_version
-        validates :snmp_version, inclusion: {:in=>[1, :"2c"], :message=>"%{value} needs to be 1, :\"2c\""}, allow_nil: true
+        validates :snmp_version, expression_inclusion: {:in=>[1, :"2c"], :message=>"%{value} needs to be 1, :\"2c\""}, allow_nil: true
 
         # @return [String, nil] Specifies the community name for the trap destination.
         attribute :community
@@ -30,11 +30,11 @@ module Ansible
 
         # @return [:other, :management, :default, nil] Specifies the name of the trap network. This option is not supported in versions of BIG-IP < 12.1.0. If used on versions < 12.1.0, it will simply be ignored.,The value C(default) was removed in BIG-IP version 13.1.0. Specifying this value when configuring a BIG-IP will cause the module to stop and report an error. The usual remedy is to choose one of the other options, such as C(management).
         attribute :network
-        validates :network, inclusion: {:in=>[:other, :management, :default], :message=>"%{value} needs to be :other, :management, :default"}, allow_nil: true
+        validates :network, expression_inclusion: {:in=>[:other, :management, :default], :message=>"%{value} needs to be :other, :management, :default"}, allow_nil: true
 
         # @return [:present, :absent, nil] When C(present), ensures that the resource exists.,When C(absent), ensures that the resource does not exist.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition

data/lib/ansible/ruby/modules/generated/network/f5/bigip_software_image.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :present, nil] When C(present), ensures that the image is uploaded.,When C(absent), ensures that the image is removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [String, nil] The image to put on the remote device.,This may be an absolute or relative location on the Ansible controller.,Image names, whether they are base ISOs or hotfix ISOs, B(must) be unique.
         attribute :image

data/lib/ansible/ruby/modules/generated/network/f5/bigip_software_install.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:activated, :installed, nil] When C(installed), ensures that the software is installed on the volume and the volume is set to be booted from. The device is B(not) rebooted into the new software.,When C(activated), performs the same operation as C(installed), but the system is rebooted to the new software.
         attribute :state
-        validates :state, inclusion: {:in=>[:activated, :installed], :message=>"%{value} needs to be :activated, :installed"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:activated, :installed], :message=>"%{value} needs to be :activated, :installed"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_software_update.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:daily, :monthly, :weekly, nil] Specifies the schedule for the automatic update check.
         attribute :frequency
-        validates :frequency, inclusion: {:in=>[:daily, :monthly, :weekly], :message=>"%{value} needs to be :daily, :monthly, :weekly"}, allow_nil: true
+        validates :frequency, expression_inclusion: {:in=>[:daily, :monthly, :weekly], :message=>"%{value} needs to be :daily, :monthly, :weekly"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_ssl_certificate.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Certificate state. This determines if the provided certificate and key is to be made C(present) on the device or C(absent).
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [String] SSL Certificate Name. This is the cert name used when importing a certificate into the F5. It also determines the filenames of the objects on the LTM.
         attribute :name

data/lib/ansible/ruby/modules/generated/network/f5/bigip_ssl_key.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the key is uploaded to the device. When C(absent), ensures that the key is removed from the device. If the key is currently in use, the module will not be able to remove the key.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [String] The name of the key.
         attribute :name

data/lib/ansible/ruby/modules/generated/network/f5/bigip_static_route.rb

@@ -49,7 +49,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the static route exists.,When C(absent), ensures that the static does not exist.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_sys_db.rb

@@ -14,11 +14,11 @@ module Ansible
 
         # @return [:present, :reset, nil] The state of the variable on the system. When C(present), guarantees that an existing variable is set to C(value). When C(reset) sets the variable back to the default value. At least one of value and state C(reset) are required.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :reset], :message=>"%{value} needs to be :present, :reset"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :reset], :message=>"%{value} needs to be :present, :reset"}, allow_nil: true
 
         # @return [Boolean, nil] The value to set the key to. At least one of value and state C(reset) are required.
         attribute :value
-        validates :value, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :value, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_sys_global.rb

@@ -40,7 +40,7 @@ module Ansible
 
         # @return [:present, nil] The state of the variable on the system. When C(present), guarantees that an existing variable is set to C(value).
         attribute :state
-        validates :state, inclusion: {:in=>[:present], :message=>"%{value} needs to be :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present], :message=>"%{value} needs to be :present"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_timer_policy.rb

@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the resource exists.,When C(absent), ensures the resource is removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_traffic_group.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the traffic group exists.,When C(absent), ensures the traffic group is removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [Object, nil] Specifies the floating Media Access Control (MAC) address associated with the floating IP addresses defined for a traffic group.,Primarily, a MAC masquerade address minimizes ARP communications or dropped packets as a result of failover.,A MAC masquerade address ensures that any traffic destined for a specific traffic group reaches an available device after failover, which happens because along with the traffic group, the MAC masquerade address floats to the available device.,Without a MAC masquerade address, the sending host must learn the MAC address for a newly-active device, either by sending an ARP request or by relying on the gratuitous ARP from the newly-active device.,To unset the MAC address, specify an empty value (C("")) to this parameter.
         attribute :mac_address

data/lib/ansible/ruby/modules/generated/network/f5/bigip_trunk.rb

@@ -21,11 +21,11 @@ module Ansible
 
         # @return [:auto, :"maximum-bandwidth", nil] Specifies, once the trunk is configured, the policy that the trunk uses to determine which member link (interface) can handle new traffic.,When creating a new trunk, if this value is not specific, the default is C(auto).,When C(auto), specifies that the system automatically determines which interfaces can handle new traffic. For the C(auto) option, the member links must all be the same media type and speed.,When C(maximum-bandwidth), specifies that the system determines which interfaces can handle new traffic based on the members' maximum bandwidth.
         attribute :link_selection_policy
-        validates :link_selection_policy, inclusion: {:in=>[:auto, :"maximum-bandwidth"], :message=>"%{value} needs to be :auto, :\"maximum-bandwidth\""}, allow_nil: true
+        validates :link_selection_policy, expression_inclusion: {:in=>[:auto, :"maximum-bandwidth"], :message=>"%{value} needs to be :auto, :\"maximum-bandwidth\""}, allow_nil: true
 
         # @return [:"destination-mac", :"source-destination-ip", :"source-destination-mac", nil] Specifies the basis for the hash that the system uses as the frame distribution algorithm. The system uses the resulting hash to determine which interface to use for forwarding traffic.,When creating a new trunk, if this parameter is not specified, the default is C(source-destination-ip).,When C(source-destination-mac), specifies that the system bases the hash on the combined MAC addresses of the source and the destination.,When C(destination-mac), specifies that the system bases the hash on the MAC address of the destination.,When C(source-destination-ip), specifies that the system bases the hash on the combined IP addresses of the source and the destination.
         attribute :frame_distribution_hash
-        validates :frame_distribution_hash, inclusion: {:in=>[:"destination-mac", :"source-destination-ip", :"source-destination-mac"], :message=>"%{value} needs to be :\"destination-mac\", :\"source-destination-ip\", :\"source-destination-mac\""}, allow_nil: true
+        validates :frame_distribution_hash, expression_inclusion: {:in=>[:"destination-mac", :"source-destination-ip", :"source-destination-mac"], :message=>"%{value} needs to be :\"destination-mac\", :\"source-destination-ip\", :\"source-destination-mac\""}, allow_nil: true
 
         # @return [Symbol, nil] When C(yes), specifies that the system supports the link aggregation control protocol (LACP), which monitors the trunk by exchanging control packets over the member links to determine the health of the links.,If LACP detects a failure in a member link, it removes the link from the link aggregation.,When creating a new trunk, if this parameter is not specified, LACP is C(no).,LACP is disabled by default for backward compatibility. If this does not apply to your network, we recommend that you enable LACP.
         attribute :lacp_enabled
@@ -33,18 +33,18 @@ module Ansible
 
         # @return [:active, :passive, nil] Specifies the operation mode for link aggregation control protocol (LACP), if LACP is enabled for the trunk.,When creating a new trunk, if this parameter is not specified, the default is C(active).,When C(active), specifies that the system periodically sends control packets regardless of whether the partner system has issued a request.,When C(passive), specifies that the system sends control packets only when the partner system has issued a request.
         attribute :lacp_mode
-        validates :lacp_mode, inclusion: {:in=>[:active, :passive], :message=>"%{value} needs to be :active, :passive"}, allow_nil: true
+        validates :lacp_mode, expression_inclusion: {:in=>[:active, :passive], :message=>"%{value} needs to be :active, :passive"}, allow_nil: true
 
         # @return [:long, :short, nil] Specifies the rate at which the system sends the LACP control packets.,When creating a new trunk, if this parameter is not specified, the default is C(long).,When C(long), specifies that the system sends an LACP control packet every 30 seconds.,When C(short), specifies that the system sends an LACP control packet every 1 seconds.
         attribute :lacp_timeout
-        validates :lacp_timeout, inclusion: {:in=>[:long, :short], :message=>"%{value} needs to be :long, :short"}, allow_nil: true
+        validates :lacp_timeout, expression_inclusion: {:in=>[:long, :short], :message=>"%{value} needs to be :long, :short"}, allow_nil: true
 
         # @return [Object, nil] Specifies the ether-type value used for the packets handled on this trunk when it is a member in a QinQ vlan.,The ether-type can be set to any string containing a valid hexadecimal 16 bits number, or any of the well known ether-types; C(0x8100), C(0x9100), C(0x88a8).,This parameter is not supported on Virtual Editions.,You should always wrap this value in quotes to prevent Ansible from interpreting the value as a literal hexadecimal number and converting it to an integer.
         attribute :qinq_ethertype
 
         # @return [:present, :absent, nil] When C(present), ensures that the resource exists.,When C(absent), ensures the resource is removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_tunnel.rb

@@ -49,7 +49,7 @@ module Ansible
 
         # @return [:default, :enabled, :disabled, nil] Allows you to configure auto last hop on a per-tunnel basis.,When creating a new tunnel, if this parameter is supported by the tunnel profile but not specified, the default is C(default).,When C(default), means that the system uses the global auto-lasthop setting to send back the request.,When C(enabled), allows the system to send return traffic to the MAC address that transmitted the request, even if the routing table points to a different network or interface. As a result, the system can send return traffic to clients even when there is no matching route.
         attribute :auto_last_hop
-        validates :auto_last_hop, inclusion: {:in=>[:default, :enabled, :disabled], :message=>"%{value} needs to be :default, :enabled, :disabled"}, allow_nil: true
+        validates :auto_last_hop, expression_inclusion: {:in=>[:default, :enabled, :disabled], :message=>"%{value} needs to be :default, :enabled, :disabled"}, allow_nil: true
 
         # @return [String, nil] Specifies the traffic group to associate with the tunnel.,This value cannot be changed after it is set. This is a limitation of BIG-IP.
         attribute :traffic_group
@@ -57,7 +57,7 @@ module Ansible
 
         # @return [:bidirectional, :inbound, :outbound, nil] Specifies how the tunnel carries traffic.,When creating a new tunnel, if this parameter is supported by the tunnel profile but not specified, the default is C(bidirectional).,When C(bidirectional), specifies that the tunnel carries both inbound and outbound traffic.,When C(inbound), specifies that the tunnel carries only incoming traffic.,When C(outbound), specifies that the tunnel carries only outgoing traffic.
         attribute :mode
-        validates :mode, inclusion: {:in=>[:bidirectional, :inbound, :outbound], :message=>"%{value} needs to be :bidirectional, :inbound, :outbound"}, allow_nil: true
+        validates :mode, expression_inclusion: {:in=>[:bidirectional, :inbound, :outbound], :message=>"%{value} needs to be :bidirectional, :inbound, :outbound"}, allow_nil: true
 
         # @return [Symbol, nil] Specifies that the tunnel operates in transparent mode.,When C(yes), you can inspect and manipulate the encapsulated traffic flowing through the BIG-IP system.,A transparent tunnel terminates a tunnel while presenting the illusion that the tunnel transits the device unmodified (that is, the BIG-IP system appears as if it were an intermediate router that simply routes IP traffic through the device).
         attribute :transparent
@@ -69,7 +69,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the tunnel exists.,When C(absent), ensures the tunnel is removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_ucs.rb

@@ -38,7 +38,7 @@ module Ansible
 
         # @return [:absent, :installed, :present, nil] When C(installed), ensures that the UCS is uploaded and installed, on the system. When C(present), ensures that the UCS is uploaded. When C(absent), the UCS will be removed from the system. When C(installed), the uploading of the UCS is idempotent, however the installation of that configuration is not idempotent.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :installed, :present], :message=>"%{value} needs to be :absent, :installed, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :installed, :present], :message=>"%{value} needs to be :absent, :installed, :present"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigip_ucs_fetch.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [Boolean, nil] Creates the UCS based on the value of C(src) if the file does not already exist on the remote system.
         attribute :create_on_missing
-        validates :create_on_missing, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :create_on_missing, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [String] A directory to save the UCS file into.
         attribute :dest
@@ -29,7 +29,7 @@ module Ansible
 
         # @return [Boolean, nil] If C(no), the file will only be transferred if the destination does not exist.
         attribute :force
-        validates :force, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :force, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [String, nil] The name of the UCS file to create on the remote server for downloading
         attribute :src

data/lib/ansible/ruby/modules/generated/network/f5/bigip_user.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:bash, :none, :tmsh, nil] Optionally set the users shell.
         attribute :shell
-        validates :shell, inclusion: {:in=>[:bash, :none, :tmsh], :message=>"%{value} needs to be :bash, :none, :tmsh"}, allow_nil: true
+        validates :shell, expression_inclusion: {:in=>[:bash, :none, :tmsh], :message=>"%{value} needs to be :bash, :none, :tmsh"}, allow_nil: true
 
         # @return [String, nil] Specifies the administrative partition to which the user has access. C(partition_access) is required when creating a new account. Should be in the form "partition:role". Valid roles include C(acceleration-policy-editor), C(admin), C(application-editor), C(auditor) C(certificate-manager), C(guest), C(irule-manager), C(manager), C(no-access) C(operator), C(resource-admin), C(user-manager), C(web-application-security-administrator), and C(web-application-security-editor). Partition portion of tuple should be an existing partition or the value 'all'.
         attribute :partition_access
@@ -30,11 +30,11 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether the account should exist or not, taking action if the state is different from what is stated.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [:always, :on_create, nil] C(always) will allow to update passwords if the user chooses to do so. C(on_create) will only set the password for newly created users. When C(username_credential) is C(root), this value will be forced to C(always).
         attribute :update_password
-        validates :update_password, inclusion: {:in=>[:always, :on_create], :message=>"%{value} needs to be :always, :on_create"}, allow_nil: true
+        validates :update_password, expression_inclusion: {:in=>[:always, :on_create], :message=>"%{value} needs to be :always, :on_create"}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition

data/lib/ansible/ruby/modules/generated/network/f5/bigip_vcmp_guest.rb

@@ -21,7 +21,7 @@ module Ansible
 
         # @return [:bridged, :isolated, :"host only", nil] Specifies the method by which the management address is used in the vCMP guest.,When C(bridged), specifies that the guest can communicate with the vCMP host's management network.,When C(isolated), specifies that the guest is isolated from the vCMP host's management network. In this case, the only way that a guest can communicate with the vCMP host is through the console port or through a self IP address on the guest that allows traffic through port 22.,When C(host only), prevents the guest from installing images and hotfixes other than those provided by the hypervisor.,If the guest setting is C(isolated) or C(host only), the C(mgmt_address) does not apply.,Concerning mode changing, changing C(bridged) to C(isolated) causes the vCMP host to remove all of the guest's management interfaces from its bridged management network. This immediately disconnects the guest's VMs from the physical management network. Changing C(isolated) to C(bridged) causes the vCMP host to dynamically add the guest's management interfaces to the bridged management network. This immediately connects all of the guest's VMs to the physical management network. Changing this property while the guest is in the C(configured) or C(provisioned) state has no immediate effect.
         attribute :mgmt_network
-        validates :mgmt_network, inclusion: {:in=>[:bridged, :isolated, :"host only"], :message=>"%{value} needs to be :bridged, :isolated, :\"host only\""}, allow_nil: true
+        validates :mgmt_network, expression_inclusion: {:in=>[:bridged, :isolated, :"host only"], :message=>"%{value} needs to be :bridged, :isolated, :\"host only\""}, allow_nil: true
 
         # @return [Symbol, nil] When C(state) is C(absent), will additionally delete the virtual disk associated with the vCMP guest. By default, this value is C(no).
         attribute :delete_virtual_disk
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [:configured, :disabled, :provisioned, :present, :absent, nil] The state of the vCMP guest on the system. Each state implies the actions of all states before it.,When C(configured), guarantees that the vCMP guest exists with the provided attributes. Additionally, ensures that the vCMP guest is turned off.,When C(disabled), behaves the same as C(configured) the name of this state is just a convenience for the user that is more understandable.,When C(provisioned), will ensure that the guest is created and installed. This state will not start the guest; use C(deployed) for that. This state is one step beyond C(present) as C(present) will not install the guest; only setup the configuration for it to be installed.,When C(present), ensures the guest is properly provisioned and starts the guest so that it is in a running state.,When C(absent), removes the vCMP from the system.
         attribute :state
-        validates :state, inclusion: {:in=>[:configured, :disabled, :provisioned, :present, :absent], :message=>"%{value} needs to be :configured, :disabled, :provisioned, :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:configured, :disabled, :provisioned, :present, :absent], :message=>"%{value} needs to be :configured, :disabled, :provisioned, :present, :absent"}, allow_nil: true
 
         # @return [Object, nil] Specifies the number of cores that the system allocates to the guest.,Each core represents a portion of CPU and memory. Therefore, the amount of memory allocated per core is directly tied to the amount of CPU. This amount of memory varies per hardware platform type.,The number you can specify depends on the type of hardware you have.,In the event of a reboot, the system persists the guest to the same slot on which it ran prior to the reboot.
         attribute :cores_per_slot

data/lib/ansible/ruby/modules/generated/network/f5/bigip_virtual_address.rb

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Specifies whether the system accepts ARP requests. When (disabled), specifies that the system does not accept ARP requests. Note that both ARP and ICMP Echo must be disabled in order for forwarding virtual servers using that virtual address to forward ICMP packets. If (enabled), then the packets are dropped.,Deprecated. Use the C(arp) parameter instead.,When creating a new virtual address, if this parameter is not specified, the default value is C(enabled).
         attribute :arp_state
-        validates :arp_state, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :arp_state, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Symbol, nil] Specifies whether the system accepts ARP requests.,When C(no), specifies that the system does not accept ARP requests.,When C(yes), then the packets are dropped.,Note that both ARP and ICMP Echo must be disabled in order for forwarding virtual servers using that virtual address to forward ICMP packets.,When creating a new virtual address, if this parameter is not specified, the default value is C(yes).
         attribute :arp
@@ -35,15 +35,15 @@ module Ansible
 
         # @return [:enabled, :disabled, :selective, nil] Specifies how the systems sends responses to (ICMP) echo requests on a per-virtual address basis for enabling route advertisement. When C(enabled), the BIG-IP system intercepts ICMP echo request packets and responds to them directly. When C(disabled), the BIG-IP system passes ICMP echo requests through to the backend servers. When (selective), causes the BIG-IP system to internally enable or disable responses based on virtual server state; C(when_any_available), C(when_all_available, or C(always), regardless of the state of any virtual servers.
         attribute :icmp_echo
-        validates :icmp_echo, inclusion: {:in=>[:enabled, :disabled, :selective], :message=>"%{value} needs to be :enabled, :disabled, :selective"}, allow_nil: true
+        validates :icmp_echo, expression_inclusion: {:in=>[:enabled, :disabled, :selective], :message=>"%{value} needs to be :enabled, :disabled, :selective"}, allow_nil: true
 
         # @return [:present, :absent, :enabled, :disabled, nil] The virtual address state. If C(absent), an attempt to delete the virtual address will be made. This will only succeed if this virtual address is not in use by a virtual server. C(present) creates the virtual address and enables it. If C(enabled), enable the virtual address if it exists. If C(disabled), create the virtual address if needed, and set state to C(disabled).
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :enabled, :disabled], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :enabled, :disabled], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled"}, allow_nil: true
 
         # @return [:always, :when_all_available, :when_any_available, nil] Specifies what routes of the virtual address the system advertises. When C(when_any_available), advertises the route when any virtual server is available. When C(when_all_available), advertises the route when all virtual servers are available. When (always), always advertises the route regardless of the virtual servers available.
         attribute :availability_calculation
-        validates :availability_calculation, inclusion: {:in=>[:always, :when_all_available, :when_any_available], :message=>"%{value} needs to be :always, :when_all_available, :when_any_available"}, allow_nil: true
+        validates :availability_calculation, expression_inclusion: {:in=>[:always, :when_all_available, :when_any_available], :message=>"%{value} needs to be :always, :when_all_available, :when_any_available"}, allow_nil: true
 
         # @return [Symbol, nil] Specifies whether the system uses route advertisement for this virtual address.,When disabled, the system does not advertise routes for this virtual address.,Deprecated. Use the C(route_advertisement) parameter instead.
         attribute :use_route_advertisement
@@ -51,7 +51,7 @@ module Ansible
 
         # @return [:disabled, :enabled, :always, :selective, :any, :all, nil] Specifies whether the system uses route advertisement for this virtual address.,When disabled, the system does not advertise routes for this virtual address.,The majority of these options are only supported on versions 13.0.0-HF1 or higher. On versions less than this, all choices expect C(disabled) will translate to C(enabled).,When C(always), the BIG-IP system will always advertise the route for the virtual address, regardless of availability status. This requires an C(enabled) virtual address.,When C(enabled), the BIG-IP system will advertise the route for the available virtual address, based on the calculation method in the availability calculation.,When C(disabled), the BIG-IP system will not advertise the route for the virtual address, regardless of the availability status.,When C(selective), you can also selectively enable ICMP echo responses, which causes the BIG-IP system to internally enable or disable responses based on virtual server state. Either C(any) virtual server, C(all) virtual servers, or C(always), regardless of the state of any virtual server.,When C(any), the BIG-IP system will advertise the route for the virtual address when any virtual server is available.,When C(all), the BIG-IP system will advertise the route for the virtual address when all virtual servers are available.
         attribute :route_advertisement
-        validates :route_advertisement, inclusion: {:in=>[:disabled, :enabled, :always, :selective, :any, :all], :message=>"%{value} needs to be :disabled, :enabled, :always, :selective, :any, :all"}, allow_nil: true
+        validates :route_advertisement, expression_inclusion: {:in=>[:disabled, :enabled, :always, :selective, :any, :all], :message=>"%{value} needs to be :disabled, :enabled, :always, :selective, :any, :all"}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition

data/lib/ansible/ruby/modules/generated/network/f5/bigip_virtual_server.rb

@@ -10,11 +10,11 @@ module Ansible
       class Bigip_virtual_server < Base
         # @return [:present, :absent, :enabled, :disabled, nil] The virtual server state. If C(absent), delete the virtual server if it exists. C(present) creates the virtual server and enable it. If C(enabled), enable the virtual server if it exists. If C(disabled), create the virtual server if needed, and set state to C(disabled).
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :enabled, :disabled], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :enabled, :disabled], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled"}, allow_nil: true
 
         # @return [:standard, :"forwarding-l2", :"forwarding-ip", :"performance-http", :"performance-l4", :stateless, :reject, :dhcp, :internal, :"message-routing", nil] Specifies the network service provided by this virtual server.,When creating a new virtual server, if this parameter is not provided, the default will be C(standard).,This value cannot be changed after it is set.,When C(standard), specifies a virtual server that directs client traffic to a load balancing pool and is the most basic type of virtual server. When you first create the virtual server, you assign an existing default pool to it. From then on, the virtual server automatically directs traffic to that default pool.,When C(forwarding-l2), specifies a virtual server that shares the same IP address as a node in an associated VLAN.,When C(forwarding-ip), specifies a virtual server like other virtual servers, except that the virtual server has no pool members to load balance. The virtual server simply forwards the packet directly to the destination IP address specified in the client request.,When C(performance-http), specifies a virtual server with which you associate a Fast HTTP profile. Together, the virtual server and profile increase the speed at which the virtual server processes HTTP requests.,When C(performance-l4), specifies a virtual server with which you associate a Fast L4 profile. Together, the virtual server and profile increase the speed at which the virtual server processes layer 4 requests.,When C(stateless), specifies a virtual server that accepts traffic matching the virtual server address and load balances the packet to the pool members without attempting to match the packet to a pre-existing connection in the connection table. New connections are immediately removed from the connection table. This addresses the requirement for one-way UDP traffic that needs to be processed at very high throughput levels, for example, load balancing syslog traffic to a pool of syslog servers. Stateless virtual servers are not suitable for processing traffic that requires stateful tracking, such as TCP traffic. Stateless virtual servers do not support iRules, persistence, connection mirroring, rateshaping, or SNAT automap.,When C(reject), specifies that the BIG-IP system rejects any traffic destined for the virtual server IP address.,When C(dhcp), specifies a virtual server that relays Dynamic Host Control Protocol (DHCP) client requests for an IP address to one or more DHCP servers, and provides DHCP server responses with an available IP address for the client.,When C(internal), specifies a virtual server that supports modification of HTTP requests and responses. Internal virtual servers enable usage of ICAP (Internet Content Adaptation Protocol) servers to modify HTTP requests and responses by creating and applying an ICAP profile and adding Request Adapt or Response Adapt profiles to the virtual server.,When C(message-routing), specifies a virtual server that uses a SIP application protocol and functions in accordance with a SIP session profile and SIP router profile.
         attribute :type
-        validates :type, inclusion: {:in=>[:standard, :"forwarding-l2", :"forwarding-ip", :"performance-http", :"performance-l4", :stateless, :reject, :dhcp, :internal, :"message-routing"], :message=>"%{value} needs to be :standard, :\"forwarding-l2\", :\"forwarding-ip\", :\"performance-http\", :\"performance-l4\", :stateless, :reject, :dhcp, :internal, :\"message-routing\""}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:standard, :"forwarding-l2", :"forwarding-ip", :"performance-http", :"performance-l4", :stateless, :reject, :dhcp, :internal, :"message-routing"], :message=>"%{value} needs to be :standard, :\"forwarding-l2\", :\"forwarding-ip\", :\"performance-http\", :\"performance-l4\", :stateless, :reject, :dhcp, :internal, :\"message-routing\""}, allow_nil: true
 
         # @return [String] Virtual server name.
         attribute :name
@@ -86,7 +86,7 @@ module Ansible
 
         # @return [:ah, :bna, :esp, :etherip, :gre, :icmp, :ipencap, :ipv6, :"ipv6-auth", :"ipv6-crypt", :"ipv6-icmp", :"isp-ip", :mux, :ospf, :sctp, :tcp, :udp, :udplite, nil] Specifies a network protocol name you want the system to use to direct traffic on this virtual server.,When creating a new virtual server, if this parameter is not specified, the default is C(tcp).,The Protocol setting is not available when you select Performance (HTTP) as the Type.,The value of this argument can be specified in either it's numeric value, or, for convenience, in a select number of named values. Refer to C(choices) for examples.,For a list of valid IP protocol numbers, refer to this page https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers,When C(type) is C(dhcp), this module will force the C(ip_protocol) parameter to be C(17) (UDP).
         attribute :ip_protocol
-        validates :ip_protocol, inclusion: {:in=>[:ah, :bna, :esp, :etherip, :gre, :icmp, :ipencap, :ipv6, :"ipv6-auth", :"ipv6-crypt", :"ipv6-icmp", :"isp-ip", :mux, :ospf, :sctp, :tcp, :udp, :udplite], :message=>"%{value} needs to be :ah, :bna, :esp, :etherip, :gre, :icmp, :ipencap, :ipv6, :\"ipv6-auth\", :\"ipv6-crypt\", :\"ipv6-icmp\", :\"isp-ip\", :mux, :ospf, :sctp, :tcp, :udp, :udplite"}, allow_nil: true
+        validates :ip_protocol, expression_inclusion: {:in=>[:ah, :bna, :esp, :etherip, :gre, :icmp, :ipencap, :ipv6, :"ipv6-auth", :"ipv6-crypt", :"ipv6-icmp", :"isp-ip", :mux, :ospf, :sctp, :tcp, :udp, :udplite], :message=>"%{value} needs to be :ah, :bna, :esp, :etherip, :gre, :icmp, :ipencap, :ipv6, :\"ipv6-auth\", :\"ipv6-crypt\", :\"ipv6-icmp\", :\"isp-ip\", :mux, :ospf, :sctp, :tcp, :udp, :udplite"}, allow_nil: true
 
         # @return [Object, nil] Applies the specify AFM policy to the virtual in an enforcing way.,When creating a new virtual, if this parameter is not specified, the enforced policy is disabled.
         attribute :firewall_enforced_policy

data/lib/ansible/ruby/modules/generated/network/f5/bigip_vlan.rb

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:absent, :present, nil] The state of the VLAN on the system. When C(present), guarantees that the VLAN exists with the provided attributes. When C(absent), removes the VLAN from the system.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [String, nil] Tag number for the VLAN. The tag number can be any integer between 1 and 4094. The system automatically assigns a tag number if you do not specify a value.
         attribute :tag
@@ -35,11 +35,11 @@ module Ansible
 
         # @return [:default, :"destination-address", :"source-address", :"dst-ip", :"src-ip", :dest, :destination, :source, :dst, :src, nil] Specifies how the traffic on the VLAN will be disaggregated. The value selected determines the traffic disaggregation method. You can choose to disaggregate traffic based on C(source-address) (the source IP address), C(destination-address) (destination IP address), or C(default), which specifies that the default CMP hash uses L4 ports.,When creating a new VLAN, if this parameter is not specified, the default of C(default) is used.
         attribute :cmp_hash
-        validates :cmp_hash, inclusion: {:in=>[:default, :"destination-address", :"source-address", :"dst-ip", :"src-ip", :dest, :destination, :source, :dst, :src], :message=>"%{value} needs to be :default, :\"destination-address\", :\"source-address\", :\"dst-ip\", :\"src-ip\", :dest, :destination, :source, :dst, :src"}, allow_nil: true
+        validates :cmp_hash, expression_inclusion: {:in=>[:default, :"destination-address", :"source-address", :"dst-ip", :"src-ip", :dest, :destination, :source, :dst, :src], :message=>"%{value} needs to be :default, :\"destination-address\", :\"source-address\", :\"dst-ip\", :\"src-ip\", :dest, :destination, :source, :dst, :src"}, allow_nil: true
 
         # @return [:inner, :outer, nil] Specifies how the disaggregator (DAG) distributes received tunnel-encapsulated packets to TMM instances. Select C(inner) to distribute packets based on information in inner headers. Select C(outer) to distribute packets based on information in outer headers without inspecting inner headers.,When creating a new VLAN, if this parameter is not specified, the default of C(outer) is used.,This parameter is not supported on Virtual Editions of BIG-IP.
         attribute :dag_tunnel
-        validates :dag_tunnel, inclusion: {:in=>[:inner, :outer], :message=>"%{value} needs to be :inner, :outer"}, allow_nil: true
+        validates :dag_tunnel, expression_inclusion: {:in=>[:inner, :outer], :message=>"%{value} needs to be :inner, :outer"}, allow_nil: true
 
         # @return [Symbol, nil] Specifies whether some of the stateless traffic on the VLAN should be disaggregated in a round-robin order instead of using a static hash. The stateless traffic includes non-IP L2 traffic, ICMP, some UDP protocols, and so on.,When creating a new VLAN, if this parameter is not specified, the default of (no) is used.
         attribute :dag_round_robin

data/lib/ansible/ruby/modules/generated/network/f5/bigiq_application_fasthttp.rb

@@ -34,11 +34,11 @@ module Ansible
 
         # @return [:absent, :present, nil] The state of the resource on the system.,When C(present), guarantees that the resource exists with the provided attributes.,When C(absent), removes the resource from the system.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [Boolean, nil] If the module should wait for the application to be created, deleted or updated.
         attribute :wait
-        validates :wait, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :wait, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/f5/bigiq_application_fastl4_tcp.rb

@@ -34,11 +34,11 @@ module Ansible
 
         # @return [:absent, :present, nil] The state of the resource on the system.,When C(present), guarantees that the resource exists with the provided attributes.,When C(absent), removes the resource from the system.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [Boolean, nil] If the module should wait for the application to be created, deleted or updated.
         attribute :wait
-        validates :wait, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :wait, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end