ansible-ruby 1.0.22 → 1.0.23

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

@@ -48,7 +48,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the monitor exists.,When C(absent), ensures the monitor 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_monitor_tcp_echo.rb

@@ -38,7 +38,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the monitor exists.,When C(absent), ensures the monitor 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_monitor_tcp_half_open.rb

@@ -42,7 +42,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the monitor exists.,When C(absent), ensures the monitor 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_monitor_udp.rb

@@ -50,7 +50,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the monitor exists.,When C(absent), ensures the monitor 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_node.rb

@@ -10,7 +10,7 @@ module Ansible
       class Bigip_node < Base
         # @return [:present, :absent, :enabled, :disabled, :offline, nil] Specifies the current state of the node. C(enabled) (All traffic allowed), specifies that system sends traffic to this node regardless of the node's state. C(disabled) (Only persistent or active connections allowed), Specifies that the node can handle only persistent or active connections. C(offline) (Only active connections allowed), Specifies that the node can handle only active connections. In all cases except C(absent), the node will be created if it does not yet exist.,Be particularly careful about changing the status of a node whose FQDN cannot be resolved. These situations disable your ability to change their C(state) to C(disabled) or C(offline). They will remain in an *Unavailable - Enabled* state.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :enabled, :disabled, :offline], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled, :offline"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :enabled, :disabled, :offline], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled, :offline"}, allow_nil: true
 
         # @return [String] Specifies the name of the node.
         attribute :name
@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:and_list, :m_of_n, :single, nil] Monitor rule type when C(monitors) is specified. When creating a new pool, if this value is not specified, the default of 'and_list' will be used.,Both C(single) and C(and_list) are functionally identical since BIG-IP considers all monitors as "a list". BIG=IP either has a list of many, or it has a list of one. Where they differ is in the extra guards that C(single) provides; namely that it only allows a single monitor.
         attribute :monitor_type
-        validates :monitor_type, inclusion: {:in=>[:and_list, :m_of_n, :single], :message=>"%{value} needs to be :and_list, :m_of_n, :single"}, allow_nil: true
+        validates :monitor_type, expression_inclusion: {:in=>[:and_list, :m_of_n, :single], :message=>"%{value} needs to be :and_list, :m_of_n, :single"}, allow_nil: true
 
         # @return [Object, nil] Monitor quorum value when C(monitor_type) is C(m_of_n).
         attribute :quorum
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [:ipv4, :ipv6, :all, nil] Specifies whether the FQDN of the node resolves to an IPv4 or IPv6 address.,When creating a new node, if this parameter is not specified and C(fqdn) is specified, this parameter will default to C(ipv4).,This parameter cannot be changed after it has been set.
         attribute :fqdn_address_type
-        validates :fqdn_address_type, inclusion: {:in=>[:ipv4, :ipv6, :all], :message=>"%{value} needs to be :ipv4, :ipv6, :all"}, allow_nil: true
+        validates :fqdn_address_type, expression_inclusion: {:in=>[:ipv4, :ipv6, :all], :message=>"%{value} needs to be :ipv4, :ipv6, :all"}, allow_nil: true
 
         # @return [Symbol, nil] Specifies whether the system automatically creates ephemeral nodes using the IP addresses returned by the resolution of a DNS query for a node defined by an FQDN.,When C(yes), the system generates an ephemeral node for each IP address returned in response to a DNS query for the FQDN of the node. Additionally, when a DNS response indicates the IP address of an ephemeral node no longer exists, the system deletes the ephemeral node.,When C(no), the system resolves a DNS query for the FQDN of the node with the single IP address associated with the FQDN.,When creating a new node, if this parameter is not specified and C(fqdn) is specified, this parameter will default to C(yes).,This parameter cannot be changed after it has been set.
         attribute :fqdn_auto_populate

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

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether the partition 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
       end
     end
   end

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

@@ -17,11 +17,11 @@ module Ansible
 
         # @return [:present, :absent, :draft, nil] When C(state) is C(present), ensures that the policy exists and is published. When C(state) is C(absent), ensures that the policy is removed, even if it is currently drafted.,When C(state) is C(draft), ensures that the policy exists and is drafted. When modifying rules, it is required that policies first be in a draft.,Drafting is only supported on versions of BIG-IP >= 12.1.0. On versions prior to that, specifying a C(state) of C(draft) will raise an error.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :draft], :message=>"%{value} needs to be :present, :absent, :draft"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :draft], :message=>"%{value} needs to be :present, :absent, :draft"}, allow_nil: true
 
         # @return [:first, :all, :best, nil] Specifies the method to determine which actions get executed in the case where there are multiple rules that match. When creating new policies, the default is C(first).,This module does not allow you to specify the C(best) strategy to use. It will choose the system default (C(/Common/best-match)) for you instead.
         attribute :strategy
-        validates :strategy, inclusion: {:in=>[:first, :all, :best], :message=>"%{value} needs to be :first, :all, :best"}, allow_nil: true
+        validates :strategy, expression_inclusion: {:in=>[:first, :all, :best], :message=>"%{value} needs to be :first, :all, :best"}, allow_nil: true
 
         # @return [Array<String>, String, nil] Specifies a list of rules that you want associated with this policy. The order of this list is the order they will be evaluated by BIG-IP. If the specified rules do not exist (for example when creating a new policy) then they will be created.,The C(conditions) for a default rule are C(all).,The C(actions) for a default rule are C(ignore).,The C(bigip_policy_rule) module can be used to create and edit existing and new rules.
         attribute :rules

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

@@ -29,7 +29,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, nil] Device partition to manage resources on.
         attribute :partition

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

@@ -17,11 +17,11 @@ module Ansible
 
         # @return [:"dynamic-ratio-member", :"dynamic-ratio-node", :"fastest-app-response", :"fastest-node", :"least-connections-member", :"least-connections-node", :"least-sessions", :"observed-member", :"observed-node", :"predictive-member", :"predictive-node", :"ratio-least-connections-member", :"ratio-least-connections-node", :"ratio-member", :"ratio-node", :"ratio-session", :"round-robin", :"weighted-least-connections-member", :"weighted-least-connections-node", nil] Load balancing method. When creating a new pool, if this value is not specified, the default of C(round-robin) will be used.
         attribute :lb_method
-        validates :lb_method, inclusion: {:in=>[:"dynamic-ratio-member", :"dynamic-ratio-node", :"fastest-app-response", :"fastest-node", :"least-connections-member", :"least-connections-node", :"least-sessions", :"observed-member", :"observed-node", :"predictive-member", :"predictive-node", :"ratio-least-connections-member", :"ratio-least-connections-node", :"ratio-member", :"ratio-node", :"ratio-session", :"round-robin", :"weighted-least-connections-member", :"weighted-least-connections-node"], :message=>"%{value} needs to be :\"dynamic-ratio-member\", :\"dynamic-ratio-node\", :\"fastest-app-response\", :\"fastest-node\", :\"least-connections-member\", :\"least-connections-node\", :\"least-sessions\", :\"observed-member\", :\"observed-node\", :\"predictive-member\", :\"predictive-node\", :\"ratio-least-connections-member\", :\"ratio-least-connections-node\", :\"ratio-member\", :\"ratio-node\", :\"ratio-session\", :\"round-robin\", :\"weighted-least-connections-member\", :\"weighted-least-connections-node\""}, allow_nil: true
+        validates :lb_method, expression_inclusion: {:in=>[:"dynamic-ratio-member", :"dynamic-ratio-node", :"fastest-app-response", :"fastest-node", :"least-connections-member", :"least-connections-node", :"least-sessions", :"observed-member", :"observed-node", :"predictive-member", :"predictive-node", :"ratio-least-connections-member", :"ratio-least-connections-node", :"ratio-member", :"ratio-node", :"ratio-session", :"round-robin", :"weighted-least-connections-member", :"weighted-least-connections-node"], :message=>"%{value} needs to be :\"dynamic-ratio-member\", :\"dynamic-ratio-node\", :\"fastest-app-response\", :\"fastest-node\", :\"least-connections-member\", :\"least-connections-node\", :\"least-sessions\", :\"observed-member\", :\"observed-node\", :\"predictive-member\", :\"predictive-node\", :\"ratio-least-connections-member\", :\"ratio-least-connections-node\", :\"ratio-member\", :\"ratio-node\", :\"ratio-session\", :\"round-robin\", :\"weighted-least-connections-member\", :\"weighted-least-connections-node\""}, allow_nil: true
 
         # @return [:and_list, :m_of_n, :single, nil] Monitor rule type when C(monitors) is specified.,When creating a new pool, if this value is not specified, the default of 'and_list' will be used.,When C(single) ensures that all specified monitors are checked, but additionally includes checks to make sure you only specified a single monitor.,When C(and_list) ensures that B(all) monitors are checked.,When C(m_of_n) ensures that C(quorum) of C(monitors) are checked. C(m_of_n) B(requires) that a C(quorum) of 1 or greater be set either in the playbook, or already existing on the device.,Both C(single) and C(and_list) are functionally identical since BIG-IP considers all monitors as "a list".
         attribute :monitor_type
-        validates :monitor_type, inclusion: {:in=>[:and_list, :m_of_n, :single], :message=>"%{value} needs to be :and_list, :m_of_n, :single"}, allow_nil: true
+        validates :monitor_type, expression_inclusion: {:in=>[:and_list, :m_of_n, :single], :message=>"%{value} needs to be :and_list, :m_of_n, :single"}, allow_nil: true
 
         # @return [Integer, nil] Monitor quorum value when C(monitor_type) is C(m_of_n).,Quorum must be a value of 1 or greater when C(monitor_type) is C(m_of_n).
         attribute :quorum
@@ -40,7 +40,7 @@ module Ansible
 
         # @return [:none, :reset, :drop, :reselect, nil] Sets the action to take when node goes down in pool.
         attribute :service_down_action
-        validates :service_down_action, inclusion: {:in=>[:none, :reset, :drop, :reselect], :message=>"%{value} needs to be :none, :reset, :drop, :reselect"}, allow_nil: true
+        validates :service_down_action, expression_inclusion: {:in=>[:none, :reset, :drop, :reselect], :message=>"%{value} needs to be :none, :reset, :drop, :reselect"}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition
@@ -48,7 +48,7 @@ module Ansible
 
         # @return [:absent, :present, nil] When C(present), guarantees that the pool exists with the provided attributes.,When C(absent), removes the pool 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 [Hash, nil] Arbitrary key/value pairs that you can attach to a pool. This is useful in situations where you might want to annotate a pool to me managed by Ansible.,Key names will be stored as strings; this includes names that are numbers.,Values for all of the keys will be stored as strings; this includes values that are numbers.,Data will be persisted, not ephemeral.
         attribute :metadata

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

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, :enabled, :disabled, :forced_offline] Pool member state.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :absent, :enabled, :disabled, :forced_offline], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled, :forced_offline"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :absent, :enabled, :disabled, :forced_offline], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled, :forced_offline"}
 
         # @return [String] Pool name. This pool must exist.
         attribute :pool
@@ -64,7 +64,7 @@ module Ansible
 
         # @return [Boolean, nil] Reuses node definitions if requested.
         attribute :reuse_nodes
-        validates :reuse_nodes, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :reuse_nodes, 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_profile_client_ssl.rb

@@ -30,11 +30,11 @@ module Ansible
 
         # @return [:"netscape-reuse-cipher-change-bug", :"microsoft-big-sslv3-buffer", :"msie-sslv2-rsa-padding", :"ssleay-080-client-dh-bug", :"tls-d5-bug", :"tls-block-padding-bug", :"dont-insert-empty-fragments", :"no-ssl", :"no-dtls", :"no-session-resumption-on-renegotiation", :"no-tlsv1.1", :"no-tlsv1.2", :"single-dh-use", :"ephemeral-rsa", :"cipher-server-preference", :"tls-rollback-bug", :"no-sslv2", :"no-sslv3", :"no-tls", :"no-tlsv1", :"pkcs1-check-1", :"pkcs1-check-2", :"netscape-ca-dn-bug", :"netscape-demo-cipher-change-bug", nil] Options that the system uses for SSL processing in the form of a list. When creating a new profile, the list is provided by the parent profile.,When a C('') or C(none) value is provided all options for SSL processing are disabled.
         attribute :options
-        validates :options, inclusion: {:in=>[:"netscape-reuse-cipher-change-bug", :"microsoft-big-sslv3-buffer", :"msie-sslv2-rsa-padding", :"ssleay-080-client-dh-bug", :"tls-d5-bug", :"tls-block-padding-bug", :"dont-insert-empty-fragments", :"no-ssl", :"no-dtls", :"no-session-resumption-on-renegotiation", :"no-tlsv1.1", :"no-tlsv1.2", :"single-dh-use", :"ephemeral-rsa", :"cipher-server-preference", :"tls-rollback-bug", :"no-sslv2", :"no-sslv3", :"no-tls", :"no-tlsv1", :"pkcs1-check-1", :"pkcs1-check-2", :"netscape-ca-dn-bug", :"netscape-demo-cipher-change-bug"], :message=>"%{value} needs to be :\"netscape-reuse-cipher-change-bug\", :\"microsoft-big-sslv3-buffer\", :\"msie-sslv2-rsa-padding\", :\"ssleay-080-client-dh-bug\", :\"tls-d5-bug\", :\"tls-block-padding-bug\", :\"dont-insert-empty-fragments\", :\"no-ssl\", :\"no-dtls\", :\"no-session-resumption-on-renegotiation\", :\"no-tlsv1.1\", :\"no-tlsv1.2\", :\"single-dh-use\", :\"ephemeral-rsa\", :\"cipher-server-preference\", :\"tls-rollback-bug\", :\"no-sslv2\", :\"no-sslv3\", :\"no-tls\", :\"no-tlsv1\", :\"pkcs1-check-1\", :\"pkcs1-check-2\", :\"netscape-ca-dn-bug\", :\"netscape-demo-cipher-change-bug\""}, allow_nil: true
+        validates :options, expression_inclusion: {:in=>[:"netscape-reuse-cipher-change-bug", :"microsoft-big-sslv3-buffer", :"msie-sslv2-rsa-padding", :"ssleay-080-client-dh-bug", :"tls-d5-bug", :"tls-block-padding-bug", :"dont-insert-empty-fragments", :"no-ssl", :"no-dtls", :"no-session-resumption-on-renegotiation", :"no-tlsv1.1", :"no-tlsv1.2", :"single-dh-use", :"ephemeral-rsa", :"cipher-server-preference", :"tls-rollback-bug", :"no-sslv2", :"no-sslv3", :"no-tls", :"no-tlsv1", :"pkcs1-check-1", :"pkcs1-check-2", :"netscape-ca-dn-bug", :"netscape-demo-cipher-change-bug"], :message=>"%{value} needs to be :\"netscape-reuse-cipher-change-bug\", :\"microsoft-big-sslv3-buffer\", :\"msie-sslv2-rsa-padding\", :\"ssleay-080-client-dh-bug\", :\"tls-d5-bug\", :\"tls-block-padding-bug\", :\"dont-insert-empty-fragments\", :\"no-ssl\", :\"no-dtls\", :\"no-session-resumption-on-renegotiation\", :\"no-tlsv1.1\", :\"no-tlsv1.2\", :\"single-dh-use\", :\"ephemeral-rsa\", :\"cipher-server-preference\", :\"tls-rollback-bug\", :\"no-sslv2\", :\"no-sslv3\", :\"no-tls\", :\"no-tlsv1\", :\"pkcs1-check-1\", :\"pkcs1-check-2\", :\"netscape-ca-dn-bug\", :\"netscape-demo-cipher-change-bug\""}, allow_nil: true
 
         # @return [:require, :"require-strict", :request, nil] Specifies the method of secure renegotiations for SSL connections. When creating a new profile, the setting is provided by the parent profile.,When C(request) is set the ssystem request secure renegotation of SSL connections.,C(require) is a default setting and when set the system permits initial SSL handshakes from clients but terminates renegotiations from unpatched clients.,The C(require-strict) setting the system requires strict renegotiation of SSL connections. In this mode the system refuses connections to insecure servers, and terminates existing SSL connections to insecure servers.
         attribute :secure_renegotiation
-        validates :secure_renegotiation, inclusion: {:in=>[:require, :"require-strict", :request], :message=>"%{value} needs to be :require, :\"require-strict\", :request"}, allow_nil: true
+        validates :secure_renegotiation, expression_inclusion: {:in=>[:require, :"require-strict", :request], :message=>"%{value} needs to be :require, :\"require-strict\", :request"}, allow_nil: true
 
         # @return [Symbol, nil] Enables or disables acceptance of non-SSL connections.,When creating a new profile, the setting is provided by the parent profile.
         attribute :allow_non_ssl
@@ -42,7 +42,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_profile_dns.rb

@@ -52,7 +52,7 @@ module Ansible
 
         # @return [:allow, :drop, :reject, :hint, :"no-error", nil] Specifies the action to take when a query does not match a Wide IP or a DNS Express Zone.,When C(allow), the BIG-IP system forwards queries to a DNS server or pool member. If a pool is not associated with a listener and the Use BIND Server on BIG-IP setting is set to Enabled, requests are forwarded to the local BIND server.,When C(drop), the BIG-IP system does not respond to the query.,When C(reject), the BIG-IP system returns the query with the REFUSED return code.,When C(hint), the BIG-IP system returns the query with a list of root name servers.,When C(no-error), the BIG-IP system returns the query with the NOERROR return code.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.
         attribute :unhandled_query_action
-        validates :unhandled_query_action, inclusion: {:in=>[:allow, :drop, :reject, :hint, :"no-error"], :message=>"%{value} needs to be :allow, :drop, :reject, :hint, :\"no-error\""}, allow_nil: true
+        validates :unhandled_query_action, expression_inclusion: {:in=>[:allow, :drop, :reject, :hint, :"no-error"], :message=>"%{value} needs to be :allow, :drop, :reject, :hint, :\"no-error\""}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition
@@ -60,7 +60,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_profile_http.rb

@@ -21,7 +21,7 @@ module Ansible
 
         # @return [:reverse, :transparent, :explicit, nil] Specifies the proxy mode for the profile.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.
         attribute :proxy_type
-        validates :proxy_type, inclusion: {:in=>[:reverse, :transparent, :explicit], :message=>"%{value} needs to be :reverse, :transparent, :explicit"}, allow_nil: true
+        validates :proxy_type, expression_inclusion: {:in=>[:reverse, :transparent, :explicit], :message=>"%{value} needs to be :reverse, :transparent, :explicit"}, allow_nil: true
 
         # @return [Object, nil] Specifies the name of a configured DNS resolver, this option is mandatory when C(proxy_type) is set to C(explicit).,Format of the name can be either be prepended by partition (C(/Common/foo)), or specified just as an object name (C(foo)).,To remove the entry a value of C(none) or C('') can be set, however the profile C(proxy_type) must not be set as C(explicit).
         attribute :dns_resolver
@@ -32,7 +32,7 @@ module Ansible
 
         # @return [:none, :all, :matching, :nodes, nil] Specifies whether the system rewrites the URIs that are part of HTTP redirect (3XX) responses.,When set to C(none) the system will not rewrite the URI in any HTTP redirect responses.,When set to C(all) the system rewrites the URI in all HTTP redirect responses.,When set to C(matching) the system rewrites the URI in any HTTP redirect responses that match the request URI.,When set to C(nodes) if the URI contains a node IP address instead of a host name, the system changes it to the virtual server address.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.
         attribute :redirect_rewrite
-        validates :redirect_rewrite, inclusion: {:in=>[:none, :all, :matching, :nodes], :message=>"%{value} needs to be :none, :all, :matching, :nodes"}, allow_nil: true
+        validates :redirect_rewrite, expression_inclusion: {:in=>[:none, :all, :matching, :nodes], :message=>"%{value} needs to be :none, :all, :matching, :nodes"}, allow_nil: true
 
         # @return [Array<String>, String, nil] Cookie names for the system to encrypt.,To remove the entry completely a value of C(none) or C('') should be set.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.
         attribute :encrypt_cookies
@@ -43,7 +43,7 @@ module Ansible
 
         # @return [:always, :on_create, nil] C(always) will update passwords if the C(encrypt_cookie_secret) is specified.,C(on_create) will only set the password for newly created profiles.
         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
@@ -51,7 +51,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_profile_http_compression.rb

@@ -25,15 +25,15 @@ module Ansible
 
         # @return [1, 2, 3, 4, 5, 6, 7, 8, 9, nil] Specifies the degree to which the system compresses the content.,Higher compression levels cause the compression process to be slower.,Valid values are between 1 (least compression and fastest) to 9 (most compression and slowest).
         attribute :gzip_level
-        validates :gzip_level, inclusion: {:in=>[1, 2, 3, 4, 5, 6, 7, 8, 9], :message=>"%{value} needs to be 1, 2, 3, 4, 5, 6, 7, 8, 9"}, allow_nil: true
+        validates :gzip_level, expression_inclusion: {:in=>[1, 2, 3, 4, 5, 6, 7, 8, 9], :message=>"%{value} needs to be 1, 2, 3, 4, 5, 6, 7, 8, 9"}, allow_nil: true
 
         # @return [1, 2, 4, 8, 16, 32, 64, 128, 256, nil] Number of kilobytes of memory that the system uses for internal compression buffers when compressing a server response.
         attribute :gzip_memory_level
-        validates :gzip_memory_level, inclusion: {:in=>[1, 2, 4, 8, 16, 32, 64, 128, 256], :message=>"%{value} needs to be 1, 2, 4, 8, 16, 32, 64, 128, 256"}, allow_nil: true
+        validates :gzip_memory_level, expression_inclusion: {:in=>[1, 2, 4, 8, 16, 32, 64, 128, 256], :message=>"%{value} needs to be 1, 2, 4, 8, 16, 32, 64, 128, 256"}, allow_nil: true
 
         # @return [1, 2, 4, 8, 16, 32, 64, 128, nil] Number of kilobytes in the window size that the system uses when compressing a server response.
         attribute :gzip_window_size
-        validates :gzip_window_size, inclusion: {:in=>[1, 2, 4, 8, 16, 32, 64, 128], :message=>"%{value} needs to be 1, 2, 4, 8, 16, 32, 64, 128"}, allow_nil: true
+        validates :gzip_window_size, expression_inclusion: {:in=>[1, 2, 4, 8, 16, 32, 64, 128], :message=>"%{value} needs to be 1, 2, 4, 8, 16, 32, 64, 128"}, allow_nil: true
 
         # @return [String, nil] Device partition to manage resources on.
         attribute :partition
@@ -41,7 +41,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_profile_oneconnect.rb

@@ -35,7 +35,7 @@ module Ansible
 
         # @return [:none, :idle, :strict, nil] When C(none), simultaneous in-flight requests and responses over TCP connections to a pool member are counted toward the limit. This is the historical behavior.,When C(idle), idle connections will be dropped as the TCP connection limit is reached. For short intervals, during the overlap of the idle connection being dropped and the new connection being established, the TCP connection limit may be exceeded.,When C(strict), the TCP connection limit is honored with no exceptions. This means that idle connections will prevent new TCP connections from being made until they expire, even if they could otherwise be reused.,C(strict) is not a recommended configuration except in very special cases with short expiration timeouts.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.
         attribute :limit_type
-        validates :limit_type, inclusion: {:in=>[:none, :idle, :strict], :message=>"%{value} needs to be :none, :idle, :strict"}, allow_nil: true
+        validates :limit_type, expression_inclusion: {:in=>[:none, :idle, :strict], :message=>"%{value} needs to be :none, :idle, :strict"}, allow_nil: true
 
         # @return [Symbol, nil] Indicates that connections may be shared not only within a virtual server, but also among similar virtual servers,When C(yes), all virtual servers that use the same OneConnect and other internal network profiles can share connections.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.
         attribute :share_pools
@@ -47,7 +47,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_profile_persistence_src_addr.rb

@@ -29,7 +29,7 @@ module Ansible
 
         # @return [:default, :carp, nil] Specifies the algorithm the system uses for hash persistence load balancing. The hash result is the input for the algorithm.,When C(default), specifies that the system uses the index of pool members to obtain the hash result for the input to the algorithm.,When C(carp), specifies that the system uses the Cache Array Routing Protocol (CARP) to obtain the hash result for the input to the algorithm.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.
         attribute :hash_algorithm
-        validates :hash_algorithm, inclusion: {:in=>[:default, :carp], :message=>"%{value} needs to be :default, :carp"}, allow_nil: true
+        validates :hash_algorithm, expression_inclusion: {:in=>[:default, :carp], :message=>"%{value} needs to be :default, :carp"}, allow_nil: true
 
         # @return [Object, nil] Specifies the duration of the persistence entries.,When creating a new profile, if this parameter is not specified, the default is provided by the parent profile.,To specify an indefinite timeout, use the value C(indefinite).,If specifying a numeric timeout, the value must be between C(1) and C(4294967295).
         attribute :entry_timeout
@@ -44,7 +44,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_profile_tcp.rb

@@ -30,7 +30,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_profile_udp.rb

@@ -30,7 +30,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the profile exists.,When C(absent), ensures the profile 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_provision.rb

@@ -10,15 +10,15 @@ module Ansible
       class Bigip_provision < Base
         # @return [:am, :afm, :apm, :asm, :avr, :cgnat, :fps, :gtm, :ilx, :lc, :ltm, :pem, :sam, :swg, :vcmp] The module to provision in BIG-IP.
         attribute :module
-        validates :module, presence: true, inclusion: {:in=>[:am, :afm, :apm, :asm, :avr, :cgnat, :fps, :gtm, :ilx, :lc, :ltm, :pem, :sam, :swg, :vcmp], :message=>"%{value} needs to be :am, :afm, :apm, :asm, :avr, :cgnat, :fps, :gtm, :ilx, :lc, :ltm, :pem, :sam, :swg, :vcmp"}
+        validates :module, presence: true, expression_inclusion: {:in=>[:am, :afm, :apm, :asm, :avr, :cgnat, :fps, :gtm, :ilx, :lc, :ltm, :pem, :sam, :swg, :vcmp], :message=>"%{value} needs to be :am, :afm, :apm, :asm, :avr, :cgnat, :fps, :gtm, :ilx, :lc, :ltm, :pem, :sam, :swg, :vcmp"}
 
         # @return [:dedicated, :nominal, :minimum, nil] Sets the provisioning level for the requested modules. Changing the level for one module may require modifying the level of another module. For example, changing one module to C(dedicated) requires setting all others to C(none). Setting the level of a module to C(none) means that the module is not activated.,This parameter is not relevant to C(cgnat) and will not be applied to the C(cgnat) module.
         attribute :level
-        validates :level, inclusion: {:in=>[:dedicated, :nominal, :minimum], :message=>"%{value} needs to be :dedicated, :nominal, :minimum"}, allow_nil: true
+        validates :level, expression_inclusion: {:in=>[:dedicated, :nominal, :minimum], :message=>"%{value} needs to be :dedicated, :nominal, :minimum"}, allow_nil: true
 
         # @return [:present, :absent, nil] The state of the provisioned module on the system. When C(present), guarantees that the specified module is provisioned at the requested level provided that there are sufficient resources on the device (such as physical RAM) to support the provisioned module. When C(absent), de-provision the module.
         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_qkview.rb

@@ -34,11 +34,11 @@ module Ansible
 
         # @return [:all, :audit, :secure, :bash_history, nil] Exclude various file from the qkview.
         attribute :exclude
-        validates :exclude, inclusion: {:in=>[:all, :audit, :secure, :bash_history], :message=>"%{value} needs to be :all, :audit, :secure, :bash_history"}, allow_nil: true
+        validates :exclude, expression_inclusion: {:in=>[:all, :audit, :secure, :bash_history], :message=>"%{value} needs to be :all, :audit, :secure, :bash_history"}, allow_nil: true
 
         # @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
       end
     end
   end

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

@@ -38,7 +38,7 @@ module Ansible
 
         # @return [:absent, :present, nil] When C(present), guarantees that the remote role exists.,When C(absent), removes the remote role 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
       end
     end
   end

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

@@ -21,7 +21,7 @@ module Ansible
 
         # @return [:absent, :present, nil] When C(present), guarantees that the remote syslog exists with the provided attributes.,When C(absent), removes the remote syslog 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
       end
     end
   end

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

@@ -37,14 +37,14 @@ module Ansible
 
         # @return [:none, :BFD, :BGP, :"IS-IS", :OSPFv2, :OSPFv3, :PIM, :RIP, :RIPng, nil] Dynamic routing protocols for the system to use in the route domain.
         attribute :routing_protocol
-        validates :routing_protocol, inclusion: {:in=>[:none, :BFD, :BGP, :"IS-IS", :OSPFv2, :OSPFv3, :PIM, :RIP, :RIPng], :message=>"%{value} needs to be :none, :BFD, :BGP, :\"IS-IS\", :OSPFv2, :OSPFv3, :PIM, :RIP, :RIPng"}, allow_nil: true
+        validates :routing_protocol, expression_inclusion: {:in=>[:none, :BFD, :BGP, :"IS-IS", :OSPFv2, :OSPFv3, :PIM, :RIP, :RIPng], :message=>"%{value} needs to be :none, :BFD, :BGP, :\"IS-IS\", :OSPFv2, :OSPFv3, :PIM, :RIP, :RIPng"}, allow_nil: true
 
         # @return [Object, nil] Service policy to associate with the route domain.
         attribute :service_policy
 
         # @return [:present, :absent, nil] Whether the route domain 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 [Symbol, nil] Specifies whether the system enforces cross-routing restrictions or not.
         attribute :strict

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

@@ -37,7 +37,7 @@ module Ansible
 
         # @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
       end
     end
   end

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

@@ -32,7 +32,7 @@ module Ansible
 
         # @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
       end
     end
   end

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

@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:absent, :present, nil] When C(present), guarantees that the Self-IP exists with the provided attributes.,When C(absent), removes the Self-IP 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 [Object, nil] The traffic group for the Self IP addresses in an active-active, redundant load balancer configuration. When creating a new Self IP, if this value is not specified, the default of C(/Common/traffic-group-local-only) will be used.
         attribute :traffic_group

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

@@ -25,7 +25,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether the resource 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_smtp.rb

@@ -33,7 +33,7 @@ module Ansible
 
         # @return [:none, :ssl, :tls, nil] Specifies whether the SMTP server requires an encrypted connection in order to send mail.
         attribute :encryption
-        validates :encryption, inclusion: {:in=>[:none, :ssl, :tls], :message=>"%{value} needs to be :none, :ssl, :tls"}, allow_nil: true
+        validates :encryption, expression_inclusion: {:in=>[:none, :ssl, :tls], :message=>"%{value} needs to be :none, :ssl, :tls"}, allow_nil: true
 
         # @return [Symbol, nil] Credentials can be set on an SMTP server's configuration even if that authentication is not used (think staging configs or emergency changes). This parameter acts as a switch to make the specified C(smtp_server_username) and C(smtp_server_password) parameters active or not.,When C(yes), the authentication parameters will be active.,When C(no), the authentication parameters will be inactive.
         attribute :authentication
@@ -49,11 +49,11 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present), ensures that the SMTP configuration exists.,When C(absent), ensures that the SMTP configuration 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 [:always, :on_create, nil] Passwords are stored encrypted, so the module cannot know if the supplied C(smtp_server_password) is the same or different than the existing password. This parameter controls the updating of the C(smtp_server_password) credential.,When C(always), will always update the password.,When C(on_create), will only set the password for newly created SMTP server configurations.
         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
       end
     end
   end