ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_mr_l3_firewall.rb

@@ -10,7 +10,7 @@ module Ansible
       class Meraki_mr_l3_firewall < Base
         # @return [:present, :query, nil] Create or modify an organization.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :query], :message=>"%{value} needs to be :present, :query"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :query], :message=>"%{value} needs to be :present, :query"}, allow_nil: true
 
         # @return [String, nil] Name of organization.
         attribute :org_name
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [Boolean, nil] Sets whether devices can talk to other devices on the same LAN.
         attribute :allow_lan_access
-        validates :allow_lan_access, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :allow_lan_access, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [NilClass, Array<Hash>, Hash, nil] List of firewall rules.
         attribute :rules

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_mx_l3_firewall.rb

@@ -10,7 +10,7 @@ module Ansible
       class Meraki_mx_l3_firewall < Base
         # @return [:present, :query, nil] Create or modify an organization.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :query], :message=>"%{value} needs to be :present, :query"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :query], :message=>"%{value} needs to be :present, :query"}, allow_nil: true
 
         # @return [String, nil] Name of organization.,If C(clone) is specified, C(org_name) is the name of the new organization.
         attribute :org_name

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_network.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :present, :query, nil] Create or modify an organization.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present, :query], :message=>"%{value} needs to be :absent, :present, :query"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present, :query], :message=>"%{value} needs to be :absent, :present, :query"}, allow_nil: true
 
         # @return [String, nil] Name of a network.
         attribute :net_name
@@ -32,7 +32,7 @@ module Ansible
 
         # @return [:appliance, :combined, :switch, :wireless, nil] Type of network device network manages.,Required when creating a network.
         attribute :type
-        validates :type, inclusion: {:in=>[:appliance, :combined, :switch, :wireless], :message=>"%{value} needs to be :appliance, :combined, :switch, :wireless"}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:appliance, :combined, :switch, :wireless], :message=>"%{value} needs to be :appliance, :combined, :switch, :wireless"}, allow_nil: true
 
         # @return [Array<String>, String, nil] Comma delimited list of tags to assign to network.
         attribute :tags

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_organization.rb

@@ -10,7 +10,7 @@ module Ansible
       class Meraki_organization < Base
         # @return [:present, :query, nil] Create or modify an organization.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :query], :message=>"%{value} needs to be :present, :query"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :query], :message=>"%{value} needs to be :present, :query"}, allow_nil: true
 
         # @return [String, nil] Organization to clone to a new organization.
         attribute :clone

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_snmp.rb

@@ -10,7 +10,7 @@ module Ansible
       class Meraki_snmp < Base
         # @return [:query, :present, nil] Specifies whether SNMP information should be queried or modified.
         attribute :state
-        validates :state, inclusion: {:in=>[:query, :present], :message=>"%{value} needs to be :query, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:query, :present], :message=>"%{value} needs to be :query, :present"}, allow_nil: true
 
         # @return [Symbol, nil] Specifies whether SNMPv2c is enabled.
         attribute :v2c_enabled
@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:MD5, :SHA, nil] Sets authentication mode for SNMPv3.
         attribute :v3_auth_mode
-        validates :v3_auth_mode, inclusion: {:in=>[:MD5, :SHA], :message=>"%{value} needs to be :MD5, :SHA"}, allow_nil: true
+        validates :v3_auth_mode, expression_inclusion: {:in=>[:MD5, :SHA], :message=>"%{value} needs to be :MD5, :SHA"}, allow_nil: true
 
         # @return [String, nil] Authentication password for SNMPv3.,Must be at least 8 characters long.
         attribute :v3_auth_pass
@@ -30,7 +30,7 @@ module Ansible
 
         # @return [:DES, :AES128, nil] Specifies privacy mode for SNMPv3.
         attribute :v3_priv_mode
-        validates :v3_priv_mode, inclusion: {:in=>[:DES, :AES128], :message=>"%{value} needs to be :DES, :AES128"}, allow_nil: true
+        validates :v3_priv_mode, expression_inclusion: {:in=>[:DES, :AES128], :message=>"%{value} needs to be :DES, :AES128"}, allow_nil: true
 
         # @return [String, nil] Privacy password for SNMPv3.,Must be at least 8 characters long.
         attribute :v3_priv_pass

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_ssid.rb

@@ -10,7 +10,7 @@ module Ansible
       class Meraki_ssid < Base
         # @return [:absent, :query, :present, nil] Specifies whether SNMP information should be queried or modified.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :query, :present], :message=>"%{value} needs to be :absent, :query, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :query, :present], :message=>"%{value} needs to be :absent, :query, :present"}, allow_nil: true
 
         # @return [Object, nil] SSID number within network.
         attribute :number
@@ -36,22 +36,22 @@ module Ansible
 
         # @return [:open, :psk, :"open-with-radius", :"8021x-meraki", :"8021x-radius", nil] Set authentication mode of network.
         attribute :auth_mode
-        validates :auth_mode, inclusion: {:in=>[:open, :psk, :"open-with-radius", :"8021x-meraki", :"8021x-radius"], :message=>"%{value} needs to be :open, :psk, :\"open-with-radius\", :\"8021x-meraki\", :\"8021x-radius\""}, allow_nil: true
+        validates :auth_mode, expression_inclusion: {:in=>[:open, :psk, :"open-with-radius", :"8021x-meraki", :"8021x-radius"], :message=>"%{value} needs to be :open, :psk, :\"open-with-radius\", :\"8021x-meraki\", :\"8021x-radius\""}, allow_nil: true
 
         # @return [:wpa, :eap, :"wpa-eap", nil] Set encryption mode of network.
         attribute :encryption_mode
-        validates :encryption_mode, inclusion: {:in=>[:wpa, :eap, :"wpa-eap"], :message=>"%{value} needs to be :wpa, :eap, :\"wpa-eap\""}, allow_nil: true
+        validates :encryption_mode, expression_inclusion: {:in=>[:wpa, :eap, :"wpa-eap"], :message=>"%{value} needs to be :wpa, :eap, :\"wpa-eap\""}, allow_nil: true
 
         # @return [Object, nil] Password for wireless network.,Requires auth_mode to be set to psk.
         attribute :psk
 
         # @return [:"WPA1 and WPA2", :"WPA2 only", nil] Encryption mode within WPA2 specification.
         attribute :wpa_encryption_mode
-        validates :wpa_encryption_mode, inclusion: {:in=>[:"WPA1 and WPA2", :"WPA2 only"], :message=>"%{value} needs to be :\"WPA1 and WPA2\", :\"WPA2 only\""}, allow_nil: true
+        validates :wpa_encryption_mode, expression_inclusion: {:in=>[:"WPA1 and WPA2", :"WPA2 only"], :message=>"%{value} needs to be :\"WPA1 and WPA2\", :\"WPA2 only\""}, allow_nil: true
 
         # @return [:None, :"Click-through splash page", :Billing, :"Password-protected with Meraki RADIUS", :"Password-protected with custom RADIUS", :"Password-protected with Active Directory", :"Password-protected with LDAP", :"SMS authentication", :"Systems Manager Sentry", :"Facebook Wi-Fi", :"Google OAuth", :"Sponsored guest", nil] Set to enable splash page and specify type of splash.
         attribute :splash_page
-        validates :splash_page, inclusion: {:in=>[:None, :"Click-through splash page", :Billing, :"Password-protected with Meraki RADIUS", :"Password-protected with custom RADIUS", :"Password-protected with Active Directory", :"Password-protected with LDAP", :"SMS authentication", :"Systems Manager Sentry", :"Facebook Wi-Fi", :"Google OAuth", :"Sponsored guest"], :message=>"%{value} needs to be :None, :\"Click-through splash page\", :Billing, :\"Password-protected with Meraki RADIUS\", :\"Password-protected with custom RADIUS\", :\"Password-protected with Active Directory\", :\"Password-protected with LDAP\", :\"SMS authentication\", :\"Systems Manager Sentry\", :\"Facebook Wi-Fi\", :\"Google OAuth\", :\"Sponsored guest\""}, allow_nil: true
+        validates :splash_page, expression_inclusion: {:in=>[:None, :"Click-through splash page", :Billing, :"Password-protected with Meraki RADIUS", :"Password-protected with custom RADIUS", :"Password-protected with Active Directory", :"Password-protected with LDAP", :"SMS authentication", :"Systems Manager Sentry", :"Facebook Wi-Fi", :"Google OAuth", :"Sponsored guest"], :message=>"%{value} needs to be :None, :\"Click-through splash page\", :Billing, :\"Password-protected with Meraki RADIUS\", :\"Password-protected with custom RADIUS\", :\"Password-protected with Active Directory\", :\"Password-protected with LDAP\", :\"SMS authentication\", :\"Systems Manager Sentry\", :\"Facebook Wi-Fi\", :\"Google OAuth\", :\"Sponsored guest\""}, allow_nil: true
 
         # @return [Object, nil] List of RADIUS servers.
         attribute :radius_servers
@@ -62,11 +62,11 @@ module Ansible
 
         # @return [:"Deny access", :"Allow access", nil] Set client access policy in case RADIUS servers aren't available.
         attribute :radius_failover_policy
-        validates :radius_failover_policy, inclusion: {:in=>[:"Deny access", :"Allow access"], :message=>"%{value} needs to be :\"Deny access\", :\"Allow access\""}, allow_nil: true
+        validates :radius_failover_policy, expression_inclusion: {:in=>[:"Deny access", :"Allow access"], :message=>"%{value} needs to be :\"Deny access\", :\"Allow access\""}, allow_nil: true
 
         # @return [:"Strict priority order", :"Round robin", nil] Set load balancing policy when multiple RADIUS servers are specified.
         attribute :radius_load_balancing_policy
-        validates :radius_load_balancing_policy, inclusion: {:in=>[:"Strict priority order", :"Round robin"], :message=>"%{value} needs to be :\"Strict priority order\", :\"Round robin\""}, allow_nil: true
+        validates :radius_load_balancing_policy, expression_inclusion: {:in=>[:"Strict priority order", :"Round robin"], :message=>"%{value} needs to be :\"Strict priority order\", :\"Round robin\""}, allow_nil: true
 
         # @return [Symbol, nil] Enable or disable RADIUS accounting.
         attribute :radius_accounting_enabled
@@ -77,7 +77,7 @@ module Ansible
 
         # @return [:"NAT mode", :"Bridge mode", :"Layer 3 roaming", :"Layer 3 roaming with a concentrator", :VPN, nil] Method of which SSID uses to assign IP addresses.
         attribute :ip_assignment_mode
-        validates :ip_assignment_mode, inclusion: {:in=>[:"NAT mode", :"Bridge mode", :"Layer 3 roaming", :"Layer 3 roaming with a concentrator", :VPN], :message=>"%{value} needs to be :\"NAT mode\", :\"Bridge mode\", :\"Layer 3 roaming\", :\"Layer 3 roaming with a concentrator\", :VPN"}, allow_nil: true
+        validates :ip_assignment_mode, expression_inclusion: {:in=>[:"NAT mode", :"Bridge mode", :"Layer 3 roaming", :"Layer 3 roaming with a concentrator", :VPN], :message=>"%{value} needs to be :\"NAT mode\", :\"Bridge mode\", :\"Layer 3 roaming\", :\"Layer 3 roaming with a concentrator\", :VPN"}, allow_nil: true
 
         # @return [Symbol, nil] Set whether to use VLAN tagging.
         attribute :use_vlan_tagging
@@ -101,11 +101,11 @@ module Ansible
 
         # @return [1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54, nil] Minimum bitrate (Mbps) allowed on SSID.
         attribute :min_bitrate
-        validates :min_bitrate, inclusion: {:in=>[1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54], :message=>"%{value} needs to be 1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54"}, allow_nil: true
+        validates :min_bitrate, expression_inclusion: {:in=>[1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54], :message=>"%{value} needs to be 1, 2, 5.5, 6, 9, 11, 12, 18, 24, 36, 48, 54"}, allow_nil: true
 
         # @return [:"Dual band operation", :"5 GHz band only", :"Dual band operation with Band Steering", nil] Set band selection mode.
         attribute :band_selection
-        validates :band_selection, inclusion: {:in=>[:"Dual band operation", :"5 GHz band only", :"Dual band operation with Band Steering"], :message=>"%{value} needs to be :\"Dual band operation\", :\"5 GHz band only\", :\"Dual band operation with Band Steering\""}, allow_nil: true
+        validates :band_selection, expression_inclusion: {:in=>[:"Dual band operation", :"5 GHz band only", :"Dual band operation with Band Steering"], :message=>"%{value} needs to be :\"Dual band operation\", :\"5 GHz band only\", :\"Dual band operation with Band Steering\""}, allow_nil: true
 
         # @return [Object, nil] Maximum bandwidth in Mbps devices on SSID can upload.
         attribute :per_client_bandwidth_limit_up

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_switchport.rb

@@ -10,7 +10,7 @@ module Ansible
       class Meraki_switchport < Base
         # @return [:query, :present, nil] Specifies whether a switchport should be queried or modified.
         attribute :state
-        validates :state, inclusion: {:in=>[:query, :present], :message=>"%{value} needs to be :query, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:query, :present], :message=>"%{value} needs to be :query, :present"}, allow_nil: true
 
         # @return [Object, nil] Number of the access policy to apply.,Only applicable to access port types.
         attribute :access_policy_number
@@ -21,7 +21,7 @@ module Ansible
 
         # @return [Boolean, nil] Whether a switchport should be enabled or disabled.
         attribute :enabled
-        validates :enabled, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :enabled, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Symbol, nil] Isolation status of switchport.
         attribute :isolation_enabled
@@ -29,7 +29,7 @@ module Ansible
 
         # @return [:"Auto negotiate", :"100Megabit (auto)", :"100 Megabit full duplex (forced)", nil] Link speed for the switchport.
         attribute :link_negotiation
-        validates :link_negotiation, inclusion: {:in=>[:"Auto negotiate", :"100Megabit (auto)", :"100 Megabit full duplex (forced)"], :message=>"%{value} needs to be :\"Auto negotiate\", :\"100Megabit (auto)\", :\"100 Megabit full duplex (forced)\""}, allow_nil: true
+        validates :link_negotiation, expression_inclusion: {:in=>[:"Auto negotiate", :"100Megabit (auto)", :"100 Megabit full duplex (forced)"], :message=>"%{value} needs to be :\"Auto negotiate\", :\"100Megabit (auto)\", :\"100 Megabit full duplex (forced)\""}, allow_nil: true
 
         # @return [String, nil] Switchport description.
         attribute :name
@@ -41,11 +41,11 @@ module Ansible
 
         # @return [Boolean, nil] Enable or disable Power Over Ethernet on a port.
         attribute :poe_enabled
-        validates :poe_enabled, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :poe_enabled, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] Enable or disable Rapid Spanning Tree Protocol on a port.
         attribute :rstp_enabled
-        validates :rstp_enabled, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :rstp_enabled, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [String, nil] Serial nubmer of the switch.
         attribute :serial
@@ -53,7 +53,7 @@ module Ansible
 
         # @return [:disabled, :"root guard", :"bpdu guard", :"loop guard", nil] Set state of STP guard.
         attribute :stp_guard
-        validates :stp_guard, inclusion: {:in=>[:disabled, :"root guard", :"bpdu guard", :"loop guard"], :message=>"%{value} needs to be :disabled, :\"root guard\", :\"bpdu guard\", :\"loop guard\""}, allow_nil: true
+        validates :stp_guard, expression_inclusion: {:in=>[:disabled, :"root guard", :"bpdu guard", :"loop guard"], :message=>"%{value} needs to be :disabled, :\"root guard\", :\"bpdu guard\", :\"loop guard\""}, allow_nil: true
 
         # @return [String, nil] Space delimited list of tags to assign to a port.
         attribute :tags
@@ -61,7 +61,7 @@ module Ansible
 
         # @return [:access, :trunk, nil] Set port type.
         attribute :type
-        validates :type, inclusion: {:in=>[:access, :trunk], :message=>"%{value} needs to be :access, :trunk"}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:access, :trunk], :message=>"%{value} needs to be :access, :trunk"}, allow_nil: true
 
         # @return [Integer, nil] VLAN number assigned to port.,If a port is of type trunk, the specified VLAN is the native VLAN.
         attribute :vlan

data/lib/ansible/ruby/modules/generated/network/meraki/meraki_vlan.rb

@@ -10,7 +10,7 @@ module Ansible
       class Meraki_vlan < Base
         # @return [:absent, :present, :query, nil] Specifies whether object should be queried, created/modified, or removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present, :query], :message=>"%{value} needs to be :absent, :present, :query"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present, :query], :message=>"%{value} needs to be :absent, :present, :query"}, allow_nil: true
 
         # @return [String, nil] Name of network which VLAN is in or should be in.
         attribute :net_name

data/lib/ansible/ruby/modules/generated/network/netact/netact_cm_command.rb

@@ -10,7 +10,7 @@ module Ansible
       class Netact_cm_command < Base
         # @return [:upload, :provision, :import, :export, :Provision_Mass_Modification] Supported operations allow user to upload actual configuration from the network, to import and provision prepared plans, or export reference or actual configuration for planning purposes. Provision_Mass_Modification enables provisioning the same parameters to multiple network elements. This operation supports modifications only to one object class at a time. With this option NetAct Configurator creates and provisions a plan to the network with the given scope and options.
         attribute :operation
-        validates :operation, presence: true, inclusion: {:in=>[:upload, :provision, :import, :export, :Provision_Mass_Modification], :message=>"%{value} needs to be :upload, :provision, :import, :export, :Provision_Mass_Modification"}
+        validates :operation, presence: true, expression_inclusion: {:in=>[:upload, :provision, :import, :export, :Provision_Mass_Modification], :message=>"%{value} needs to be :upload, :provision, :import, :export, :Provision_Mass_Modification"}
 
         # @return [Object, nil] user specified operation name
         attribute :opsName
@@ -30,11 +30,11 @@ module Ansible
 
         # @return [:plan, :actual, :reference, :template, :siteTemplate, nil] Specifies the type of the export operation.
         attribute :typeOption
-        validates :typeOption, inclusion: {:in=>[:plan, :actual, :reference, :template, :siteTemplate], :message=>"%{value} needs to be :plan, :actual, :reference, :template, :siteTemplate"}, allow_nil: true
+        validates :typeOption, expression_inclusion: {:in=>[:plan, :actual, :reference, :template, :siteTemplate], :message=>"%{value} needs to be :plan, :actual, :reference, :template, :siteTemplate"}, allow_nil: true
 
         # @return [:RAML2, :CSV, :XLSX, nil] Indicates file format.
         attribute :fileFormat
-        validates :fileFormat, inclusion: {:in=>[:RAML2, :CSV, :XLSX], :message=>"%{value} needs to be :RAML2, :CSV, :XLSX"}, allow_nil: true
+        validates :fileFormat, expression_inclusion: {:in=>[:RAML2, :CSV, :XLSX], :message=>"%{value} needs to be :RAML2, :CSV, :XLSX"}, allow_nil: true
 
         # @return [String, nil] Specifies a file name. Valid for Import and Export operations.
         attribute :fileName

data/lib/ansible/ruby/modules/generated/network/netconf/netconf_config.rb

@@ -22,15 +22,15 @@ module Ansible
 
         # @return [:xml, :text, nil] The format of the configuration provided as value of C(content). Accepted values are I(xml) and I(text) and the given configuration format should be supported by remote Netconf server.
         attribute :format
-        validates :format, inclusion: {:in=>[:xml, :text], :message=>"%{value} needs to be :xml, :text"}, allow_nil: true
+        validates :format, expression_inclusion: {:in=>[:xml, :text], :message=>"%{value} needs to be :xml, :text"}, allow_nil: true
 
         # @return [:never, :always, :"if-supported", nil] Instructs the module to explicitly lock the datastore specified as C(target). By setting the option value I(always) is will explicitly lock the datastore mentioned in C(target) option. It the value is I(never) it will not lock the C(target) datastore. The value I(if-supported) lock the C(target) datastore only if it is supported by the remote Netconf server.
         attribute :lock
-        validates :lock, inclusion: {:in=>[:never, :always, :"if-supported"], :message=>"%{value} needs to be :never, :always, :\"if-supported\""}, allow_nil: true
+        validates :lock, expression_inclusion: {:in=>[:never, :always, :"if-supported"], :message=>"%{value} needs to be :never, :always, :\"if-supported\""}, allow_nil: true
 
         # @return [:merge, :replace, :none, nil] The default operation for <edit-config> rpc, valid values are I(merge), I(replace) and I(none). If the default value is merge, the configuration data in the C(content) option is merged at the corresponding level in the C(target) datastore. If the value is replace the data in the C(content) option completely replaces the configuration in the C(target) datastore. If the value is none the C(target) datastore is unaffected by the configuration in the config option, unless and until the incoming configuration data uses the C(operation) operation to request a different operation.
         attribute :default_operation
-        validates :default_operation, inclusion: {:in=>[:merge, :replace, :none], :message=>"%{value} needs to be :merge, :replace, :none"}, allow_nil: true
+        validates :default_operation, expression_inclusion: {:in=>[:merge, :replace, :none], :message=>"%{value} needs to be :merge, :replace, :none"}, allow_nil: true
 
         # @return [Integer, nil] This argument will configure a timeout value for the commit to be confirmed before it is automatically rolled back. If the C(confirm_commit) argument is set to False, this argument is silently ignored. If the value of this argument is set to 0, the commit is confirmed immediately. The remote host MUST support :candidate and :confirmed-commit capability for this option to .
         attribute :confirm
@@ -38,27 +38,27 @@ module Ansible
 
         # @return [:yes, :no, nil] This argument will execute commit operation on remote device. It can be used to confirm a previous commit.
         attribute :confirm_commit
-        validates :confirm_commit, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :confirm_commit, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:"stop-on-error", :"continue-on-error", :"rollback-on-error", nil] This option control the netconf server action after a error is occured while editing the configuration. If the value is I(stop-on-error) abort the config edit on first error, if value is I(continue-on-error) it continues to process configuration data on error, error is recorded and negative response is generated if any errors occur. If value is C(rollback-on-error) it rollback to the original configuration in case any error occurs, this requires the remote Netconf server to support the :rollback-on-error capability.
         attribute :error_option
-        validates :error_option, inclusion: {:in=>[:"stop-on-error", :"continue-on-error", :"rollback-on-error"], :message=>"%{value} needs to be :\"stop-on-error\", :\"continue-on-error\", :\"rollback-on-error\""}, allow_nil: true
+        validates :error_option, expression_inclusion: {:in=>[:"stop-on-error", :"continue-on-error", :"rollback-on-error"], :message=>"%{value} needs to be :\"stop-on-error\", :\"continue-on-error\", :\"rollback-on-error\""}, allow_nil: true
 
         # @return [Boolean, nil] The C(save) argument instructs the module to save the configuration in C(target) datastore to the startup-config if changed and if :startup capability is supported by Netconf server.
         attribute :save
-        validates :save, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :save, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [:yes, :no, nil] This argument will cause the module to create a full backup of the current C(running-config) from the remote device before any changes are made.  The backup file is written to the C(backup) folder in the playbook root directory or role root directory, if playbook is part of an ansible role. If the directory does not exist, it is created.
         attribute :backup
-        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :backup, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] It instructs the module to delete the configuration from value mentioned in C(target) datastore.
         attribute :delete
-        validates :delete, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :delete, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Boolean, nil] This boolean flag controls if the configuration changes should be committed or not after editing the candidate datastore. This option is supported only if remote Netconf server supports :candidate capability. If the value is set to I(False) commit won't be issued after edit-config operation and user needs to handle commit or discard-changes explicitly.
         attribute :commit
-        validates :commit, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :commit, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Symbol, nil] This boolean flag if set validates the content of datastore given in C(target) option. For this option to work remote Netconf server shoule support :validate capability.
         attribute :validate

data/lib/ansible/ruby/modules/generated/network/netconf/netconf_get.rb

@@ -11,7 +11,7 @@ module Ansible
       class Netconf_get < Base
         # @return [:running, :candidate, :startup, nil] This argument specifies the datastore from which configuration data should be fetched. Valid values are I(running), I(candidate) and I(startup). If the C(source) value is not set both configuration and state information are returned in response from running datastore.
         attribute :source
-        validates :source, inclusion: {:in=>[:running, :candidate, :startup], :message=>"%{value} needs to be :running, :candidate, :startup"}, allow_nil: true
+        validates :source, expression_inclusion: {:in=>[:running, :candidate, :startup], :message=>"%{value} needs to be :running, :candidate, :startup"}, allow_nil: true
 
         # @return [String, nil] This argument specifies the XML string which acts as a filter to restrict the portions of the data to be are retrieved from the remote device. If this option is not specified entire configuration or state data is returned in result depending on the value of C(source) option. The C(filter) value can be either XML string or XPath, if the filter is in XPath format the NETCONF server running on remote host should support xpath capability else it will result in an error.
         attribute :filter
@@ -19,11 +19,11 @@ module Ansible
 
         # @return [:json, :pretty, :xml, nil] Encoding scheme to use when serializing output from the device. The option I(json) will serialize the output as JSON data. If the option value is I(json) it requires jxmlease to be installed on control node. The option I(pretty) is similar to received XML response but is using human readable format (spaces, new lines). The option value I(xml) is similar to received XML response but removes all XML namespaces.
         attribute :display
-        validates :display, inclusion: {:in=>[:json, :pretty, :xml], :message=>"%{value} needs to be :json, :pretty, :xml"}, allow_nil: true
+        validates :display, expression_inclusion: {:in=>[:json, :pretty, :xml], :message=>"%{value} needs to be :json, :pretty, :xml"}, allow_nil: true
 
         # @return [:never, :always, :"if-supported", nil] Instructs the module to explicitly lock the datastore specified as C(source). If no I(source) is defined, the I(running) datastore will be locked. By setting the option value I(always) is will explicitly lock the datastore mentioned in C(source) option. By setting the option value I(never) it will not lock the C(source) datastore. The value I(if-supported) allows better interworking with NETCONF servers, which do not support the (un)lock operation for all supported datastores.
         attribute :lock
-        validates :lock, inclusion: {:in=>[:never, :always, :"if-supported"], :message=>"%{value} needs to be :never, :always, :\"if-supported\""}, allow_nil: true
+        validates :lock, expression_inclusion: {:in=>[:never, :always, :"if-supported"], :message=>"%{value} needs to be :never, :always, :\"if-supported\""}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/netconf/netconf_rpc.rb

@@ -23,7 +23,7 @@ module Ansible
 
         # @return [:json, :pretty, :xml, nil] Encoding scheme to use when serializing output from the device. The option I(json) will serialize the output as JSON data. If the option value is I(json) it requires jxmlease to be installed on control node. The option I(pretty) is similar to received XML response but is using human readable format (spaces, new lines). The option value I(xml) is similar to received XML response but removes all XML namespaces.
         attribute :display
-        validates :display, inclusion: {:in=>[:json, :pretty, :xml], :message=>"%{value} needs to be :json, :pretty, :xml"}, allow_nil: true
+        validates :display, expression_inclusion: {:in=>[:json, :pretty, :xml], :message=>"%{value} needs to be :json, :pretty, :xml"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/netscaler/netscaler_cs_vserver.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:HTTP, :SSL, :TCP, :FTP, :RTSP, :SSL_TCP, :UDP, :DNS, :SIP_UDP, :SIP_TCP, :SIP_SSL, :ANY, :RADIUS, :RDP, :MYSQL, :MSSQL, :DIAMETER, :SSL_DIAMETER, :DNS_TCP, :ORACLE, :SMPP, nil] Protocol used by the virtual server.
         attribute :servicetype
-        validates :servicetype, inclusion: {:in=>[:HTTP, :SSL, :TCP, :FTP, :RTSP, :SSL_TCP, :UDP, :DNS, :SIP_UDP, :SIP_TCP, :SIP_SSL, :ANY, :RADIUS, :RDP, :MYSQL, :MSSQL, :DIAMETER, :SSL_DIAMETER, :DNS_TCP, :ORACLE, :SMPP], :message=>"%{value} needs to be :HTTP, :SSL, :TCP, :FTP, :RTSP, :SSL_TCP, :UDP, :DNS, :SIP_UDP, :SIP_TCP, :SIP_SSL, :ANY, :RADIUS, :RDP, :MYSQL, :MSSQL, :DIAMETER, :SSL_DIAMETER, :DNS_TCP, :ORACLE, :SMPP"}, allow_nil: true
+        validates :servicetype, expression_inclusion: {:in=>[:HTTP, :SSL, :TCP, :FTP, :RTSP, :SSL_TCP, :UDP, :DNS, :SIP_UDP, :SIP_TCP, :SIP_SSL, :ANY, :RADIUS, :RDP, :MYSQL, :MSSQL, :DIAMETER, :SSL_DIAMETER, :DNS_TCP, :ORACLE, :SMPP], :message=>"%{value} needs to be :HTTP, :SSL, :TCP, :FTP, :RTSP, :SSL_TCP, :UDP, :DNS, :SIP_UDP, :SIP_TCP, :SIP_SSL, :ANY, :RADIUS, :RDP, :MYSQL, :MSSQL, :DIAMETER, :SSL_DIAMETER, :DNS_TCP, :ORACLE, :SMPP"}, allow_nil: true
 
         # @return [String, nil] IP address of the content switching virtual server.,Minimum length = 1
         attribute :ipv46
@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:GSLB, nil] Virtual server target type.
         attribute :targettype
-        validates :targettype, inclusion: {:in=>[:GSLB], :message=>"%{value} needs to be :GSLB"}, allow_nil: true
+        validates :targettype, expression_inclusion: {:in=>[:GSLB], :message=>"%{value} needs to be :GSLB"}, allow_nil: true
 
         # @return [Object, nil] IP address pattern, in dotted decimal notation, for identifying packets to be accepted by the virtual server. The IP Mask parameter specifies which part of the destination IP address is matched against the pattern. Mutually exclusive with the IP Address parameter.,For example, if the IP pattern assigned to the virtual server is C(198.51.100.0) and the IP mask is C(255.255.240.0) (a forward mask), the first 20 bits in the destination IP addresses are matched with the first 20 bits in the pattern. The virtual server accepts requests with IP addresses that range from 198.51.96.1 to 198.51.111.254. You can also use a pattern such as C(0.0.2.2) and a mask such as C(0.0.255.255) (a reverse mask).,If a destination IP address matches more than one IP pattern, the pattern with the longest match is selected, and the associated virtual server processes the request. For example, if the virtual servers, C(vs1) and C(vs2), have the same IP pattern, C(0.0.100.128), but different IP masks of C(0.0.255.255) and C(0.0.224.255), a destination IP address of 198.51.100.128 has the longest match with the IP pattern of C(vs1). If a destination IP address matches two or more virtual servers to the same extent, the request is processed by the virtual server whose port number matches the port number in the request.
         attribute :ippattern
@@ -43,7 +43,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Enable state updates for a specific content switching virtual server. By default, the Content Switching virtual server is always UP, regardless of the state of the Load Balancing virtual servers bound to it. This parameter interacts with the global setting as follows:,Global Level | Vserver Level | Result,enabled enabled enabled,enabled disabled enabled,disabled enabled enabled,disabled disabled disabled,If you want to enable state updates for only some content switching virtual servers, be sure to disable the state update parameter.
         attribute :stateupdate
-        validates :stateupdate, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :stateupdate, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Symbol, nil] Use this option to specify whether a virtual server, used for load balancing or content switching, routes requests to the cache redirection virtual server before sending it to the configured servers.
         attribute :cacheable
@@ -57,7 +57,7 @@ module Ansible
 
         # @return [:RULE, :URL, nil] Type of precedence to use for both RULE-based and URL-based policies on the content switching virtual server. With the default C(RULE) setting, incoming requests are evaluated against the rule-based content switching policies. If none of the rules match, the URL in the request is evaluated against the URL-based content switching policies.
         attribute :precedence
-        validates :precedence, inclusion: {:in=>[:RULE, :URL], :message=>"%{value} needs to be :RULE, :URL"}, allow_nil: true
+        validates :precedence, expression_inclusion: {:in=>[:RULE, :URL], :message=>"%{value} needs to be :RULE, :URL"}, allow_nil: true
 
         # @return [Symbol, nil] Consider case in URLs (for policies that use URLs instead of RULES). For example, with the C(on) setting, the URLs /a/1.html and /A/1.HTML are treated differently and can have different targets (set by content switching policies). With the C(off) setting, /a/1.html and /A/1.HTML are switched to the same target.
         attribute :casesensitive
@@ -65,11 +65,11 @@ module Ansible
 
         # @return [:CONNECTION, :DYNAMICCONNECTION, :BANDWIDTH, :HEALTH, :NONE, nil] Type of spillover used to divert traffic to the backup virtual server when the primary virtual server reaches the spillover threshold. Connection spillover is based on the number of connections. Bandwidth spillover is based on the total Kbps of incoming and outgoing traffic.
         attribute :somethod
-        validates :somethod, inclusion: {:in=>[:CONNECTION, :DYNAMICCONNECTION, :BANDWIDTH, :HEALTH, :NONE], :message=>"%{value} needs to be :CONNECTION, :DYNAMICCONNECTION, :BANDWIDTH, :HEALTH, :NONE"}, allow_nil: true
+        validates :somethod, expression_inclusion: {:in=>[:CONNECTION, :DYNAMICCONNECTION, :BANDWIDTH, :HEALTH, :NONE], :message=>"%{value} needs to be :CONNECTION, :DYNAMICCONNECTION, :BANDWIDTH, :HEALTH, :NONE"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] Maintain source-IP based persistence on primary and backup virtual servers.
         attribute :sopersistence
-        validates :sopersistence, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :sopersistence, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Time-out value, in minutes, for spillover persistence.,Minimum value = C(2),Maximum value = C(1440)
         attribute :sopersistencetimeout
@@ -79,26 +79,26 @@ module Ansible
 
         # @return [:DROP, :ACCEPT, :REDIRECT, nil] Action to be performed if spillover is to take effect, but no backup chain to spillover is usable or exists.
         attribute :sobackupaction
-        validates :sobackupaction, inclusion: {:in=>[:DROP, :ACCEPT, :REDIRECT], :message=>"%{value} needs to be :DROP, :ACCEPT, :REDIRECT"}, allow_nil: true
+        validates :sobackupaction, expression_inclusion: {:in=>[:DROP, :ACCEPT, :REDIRECT], :message=>"%{value} needs to be :DROP, :ACCEPT, :REDIRECT"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] State of port rewrite while performing HTTP redirect.
         attribute :redirectportrewrite
-        validates :redirectportrewrite, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :redirectportrewrite, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] Flush all active transactions associated with a virtual server whose state transitions from UP to DOWN. Do not enable this option for applications that must complete their transactions.
         attribute :downstateflush
-        validates :downstateflush, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :downstateflush, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Name of the backup virtual server that you are configuring. Must begin with an ASCII alphanumeric or underscore C(_) character, and must contain only ASCII alphanumeric, underscore C(_), hash C(#), period C(.), space C( ), colon C(:), at sign C(@), equal sign C(=), and hyphen C(-) characters. Can be changed after the backup virtual server is created. You can assign a different backup virtual server or rename the existing virtual server.,Minimum length = 1
         attribute :backupvserver
 
         # @return [:enabled, :disabled, nil] Continue forwarding the traffic to backup virtual server even after the primary server comes UP from the DOWN state.
         attribute :disableprimaryondown
-        validates :disableprimaryondown, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :disableprimaryondown, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:OFF, :VIPADDR, :V6TOV4MAPPING, nil] Insert the virtual server's VIP address and port number in the request header. Available values function as follows:,C(VIPADDR) - Header contains the vserver's IP address and port number without any translation.,C(OFF) - The virtual IP and port header insertion option is disabled.,C(V6TOV4MAPPING) - Header contains the mapped IPv4 address corresponding to the IPv6 address of the vserver and the port number. An IPv6 address can be mapped to a user-specified IPv4 address using the set ns ip6 command.
         attribute :insertvserveripport
-        validates :insertvserveripport, inclusion: {:in=>[:OFF, :VIPADDR, :V6TOV4MAPPING], :message=>"%{value} needs to be :OFF, :VIPADDR, :V6TOV4MAPPING"}, allow_nil: true
+        validates :insertvserveripport, expression_inclusion: {:in=>[:OFF, :VIPADDR, :V6TOV4MAPPING], :message=>"%{value} needs to be :OFF, :VIPADDR, :V6TOV4MAPPING"}, allow_nil: true
 
         # @return [Object, nil] Name of virtual server IP and port header, for use with the VServer IP Port Insertion parameter.,Minimum length = 1
         attribute :vipheader
@@ -126,7 +126,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Process traffic with the push virtual server that is bound to this content switching virtual server (specified by the Push VServer parameter). The service type of the push virtual server should be either C(HTTP) or C(SSL).
         attribute :push
-        validates :push, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :push, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Name of the load balancing virtual server, of type C(PUSH) or C(SSL_PUSH), to which the server pushes updates received on the client-facing load balancing virtual server.,Minimum length = 1
         attribute :pushvserver
@@ -149,14 +149,14 @@ module Ansible
 
         # @return [:"10G", :"11G", nil] Oracle server version.
         attribute :oracleserverversion
-        validates :oracleserverversion, inclusion: {:in=>[:"10G", :"11G"], :message=>"%{value} needs to be :\"10G\", :\"11G\""}, allow_nil: true
+        validates :oracleserverversion, expression_inclusion: {:in=>[:"10G", :"11G"], :message=>"%{value} needs to be :\"10G\", :\"11G\""}, allow_nil: true
 
         # @return [Object, nil] Information about this virtual server.
         attribute :comment
 
         # @return [70, 2000, :"2000SP1", 2005, 2008, :"2008R2", 2012, 2014, nil] The version of the MSSQL server.
         attribute :mssqlserverversion
-        validates :mssqlserverversion, inclusion: {:in=>[70, 2000, :"2000SP1", 2005, 2008, :"2008R2", 2012, 2014], :message=>"%{value} needs to be 70, 2000, :\"2000SP1\", 2005, 2008, :\"2008R2\", 2012, 2014"}, allow_nil: true
+        validates :mssqlserverversion, expression_inclusion: {:in=>[70, 2000, :"2000SP1", 2005, 2008, :"2008R2", 2012, 2014], :message=>"%{value} needs to be 70, 2000, :\"2000SP1\", 2005, 2008, :\"2008R2\", 2012, 2014"}, allow_nil: true
 
         # @return [Object, nil] Use L2 Parameters to identify a connection.
         attribute :l2conn
@@ -175,18 +175,18 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Enable logging appflow flow information.
         attribute :appflowlog
-        validates :appflowlog, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :appflowlog, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] The name of the network profile.,Minimum length = 1,Maximum length = 127
         attribute :netprofile
 
         # @return [:PASSIVE, :ACTIVE, nil] Can be active or passive.
         attribute :icmpvsrresponse
-        validates :icmpvsrresponse, inclusion: {:in=>[:PASSIVE, :ACTIVE], :message=>"%{value} needs to be :PASSIVE, :ACTIVE"}, allow_nil: true
+        validates :icmpvsrresponse, expression_inclusion: {:in=>[:PASSIVE, :ACTIVE], :message=>"%{value} needs to be :PASSIVE, :ACTIVE"}, allow_nil: true
 
         # @return [:PASSIVE, :ACTIVE, nil] A host route is injected according to the setting on the virtual servers,* If set to C(PASSIVE) on all the virtual servers that share the IP address, the appliance always injects the hostroute.,* If set to C(ACTIVE) on all the virtual servers that share the IP address, the appliance injects even if one virtual server is UP.,* If set to C(ACTIVE) on some virtual servers and C(PASSIVE) on the others, the appliance, injects even if one virtual server set to C(ACTIVE) is UP.
         attribute :rhistate
-        validates :rhistate, inclusion: {:in=>[:PASSIVE, :ACTIVE], :message=>"%{value} needs to be :PASSIVE, :ACTIVE"}, allow_nil: true
+        validates :rhistate, expression_inclusion: {:in=>[:PASSIVE, :ACTIVE], :message=>"%{value} needs to be :PASSIVE, :ACTIVE"}, allow_nil: true
 
         # @return [Object, nil] Name of the authentication profile to be used when authentication is turned on.
         attribute :authnprofile
@@ -220,7 +220,7 @@ module Ansible
 
         # @return [:yes, :no, nil] When set to C(yes) the cs vserver will be disabled.,When set to C(no) the cs vserver will be enabled.,Note that due to limitations of the underlying NITRO API a C(disabled) state change alone does not cause the module result to report a changed status.
         attribute :disabled
-        validates :disabled, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :disabled, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end