ansible-ruby 1.0.22 → 1.0.23

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

@@ -21,7 +21,7 @@ module Ansible
 
         # @return [:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE, nil] Type of service to create.
         attribute :servicetype
-        validates :servicetype, inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE"}, allow_nil: true
+        validates :servicetype, expression_inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE"}, allow_nil: true
 
         # @return [Object, nil] Port on which the load balancing entity represented by this GSLB service listens.,Minimum value = 1,Range 1 - 65535,* in CLI is represented as 65535 in NITRO API
         attribute :port
@@ -45,14 +45,14 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] In the request that is forwarded to the GSLB service, insert a header that stores the client's IP address. Client IP header insertion is used in connection-proxy based site persistence.
         attribute :cip
-        validates :cip, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :cip, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Name for the HTTP header that stores the client's IP address. Used with the Client IP option. If client IP header insertion is enabled on the service and a name is not specified for the header, the NetScaler appliance uses the name specified by the cipHeader parameter in the set ns param command or, in the GUI, the Client IP Header parameter in the Configure HTTP Parameters dialog box.,Minimum length = 1
         attribute :cipheader
 
         # @return [:ConnectionProxy, :HTTPRedirect, :NONE, nil] Use cookie-based site persistence. Applicable only to C(HTTP) and C(SSL) GSLB services.
         attribute :sitepersistence
-        validates :sitepersistence, inclusion: {:in=>[:ConnectionProxy, :HTTPRedirect, :NONE], :message=>"%{value} needs to be :ConnectionProxy, :HTTPRedirect, :NONE"}, allow_nil: true
+        validates :sitepersistence, expression_inclusion: {:in=>[:ConnectionProxy, :HTTPRedirect, :NONE], :message=>"%{value} needs to be :ConnectionProxy, :HTTPRedirect, :NONE"}, allow_nil: true
 
         # @return [Object, nil] The site's prefix string. When the service is bound to a GSLB virtual server, a GSLB site domain is generated internally for each bound service-domain pair by concatenating the site prefix of the service and the name of the domain. If the special string NONE is specified, the site-prefix string is unset. When implementing HTTP redirect site persistence, the NetScaler appliance redirects GSLB requests to GSLB services by using their site domains.
         attribute :siteprefix
@@ -65,7 +65,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Flush all active transactions associated with the GSLB service when its state transitions from UP to DOWN. Do not enable this option for services that must complete their transactions. Applicable if connection proxy based site persistence is used.
         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] Maximum number of SSL VPN users that can be logged on concurrently to the VPN virtual server that is represented by this GSLB service. A GSLB service whose user count reaches the maximum is not considered when a GSLB decision is made, until the count drops below the maximum.,Minimum value = C(0),Maximum value = C(65535)
         attribute :maxaaausers
@@ -81,7 +81,7 @@ 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] IP address for the GSLB service. Should represent a load balancing, content switching, or VPN virtual server on the NetScaler appliance, or the IP address of another load balancing device.
         attribute :ipaddress

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

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:REMOTE, :LOCAL, nil] Type of site to create. If the type is not specified, the appliance automatically detects and sets the type on the basis of the IP address being assigned to the site. If the specified site IP address is owned by the appliance (for example, a MIP address or SNIP address), the site is a local site. Otherwise, it is a remote site.
         attribute :sitetype
-        validates :sitetype, inclusion: {:in=>[:REMOTE, :LOCAL], :message=>"%{value} needs to be :REMOTE, :LOCAL"}, allow_nil: true
+        validates :sitetype, expression_inclusion: {:in=>[:REMOTE, :LOCAL], :message=>"%{value} needs to be :REMOTE, :LOCAL"}, allow_nil: true
 
         # @return [String, nil] IP address for the GSLB site. The GSLB site uses this IP address to communicate with other GSLB sites. For a local site, use any IP address that is owned by the appliance (for example, a SNIP or MIP address, or the IP address of the ADNS service).,Minimum length = 1
         attribute :siteipaddress
@@ -26,19 +26,19 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Exchange metrics with other sites. Metrics are exchanged by using Metric Exchange Protocol (MEP). The appliances in the GSLB setup exchange health information once every second.,If you disable metrics exchange, you can use only static load balancing methods (such as round robin, static proximity, or the hash-based methods), and if you disable metrics exchange when a dynamic load balancing method (such as least connection) is in operation, the appliance falls back to round robin. Also, if you disable metrics exchange, you must use a monitor to determine the state of GSLB services. Otherwise, the service is marked as DOWN.
         attribute :metricexchange
-        validates :metricexchange, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :metricexchange, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] Exchange, with other GSLB sites, network metrics such as round-trip time (RTT), learned from communications with various local DNS (LDNS) servers used by clients. RTT information is used in the dynamic RTT load balancing method, and is exchanged every 5 seconds.
         attribute :nwmetricexchange
-        validates :nwmetricexchange, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :nwmetricexchange, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] Exchange persistent session entries with other GSLB sites every five seconds.
         attribute :sessionexchange
-        validates :sessionexchange, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :sessionexchange, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:ALWAYS, :MEPDOWN, :MEPDOWN_SVCDOWN, nil] Specify the conditions under which the GSLB service must be monitored by a monitor, if one is bound. Available settings function as follows:,* C(ALWAYS) - Monitor the GSLB service at all times.,* C(MEPDOWN) - Monitor the GSLB service only when the exchange of metrics through the Metrics Exchange Protocol (MEP) is disabled.,C(MEPDOWN_SVCDOWN) - Monitor the service in either of the following situations:,* The exchange of metrics through MEP is disabled.,* The exchange of metrics through MEP is enabled but the status of the service, learned through metrics exchange, is DOWN.
         attribute :triggermonitor
-        validates :triggermonitor, inclusion: {:in=>[:ALWAYS, :MEPDOWN, :MEPDOWN_SVCDOWN], :message=>"%{value} needs to be :ALWAYS, :MEPDOWN, :MEPDOWN_SVCDOWN"}, allow_nil: true
+        validates :triggermonitor, expression_inclusion: {:in=>[:ALWAYS, :MEPDOWN, :MEPDOWN_SVCDOWN], :message=>"%{value} needs to be :ALWAYS, :MEPDOWN, :MEPDOWN_SVCDOWN"}, allow_nil: true
 
         # @return [Object, nil] Parent site of the GSLB site, in a parent-child topology.
         attribute :parentsite

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

@@ -13,19 +13,19 @@ module Ansible
 
         # @return [:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE, nil] Protocol used by services bound to the virtual server.,
         attribute :servicetype
-        validates :servicetype, inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE"}, allow_nil: true
+        validates :servicetype, expression_inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :NNTP, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :RADIUS, :RDP, :RTSP, :MYSQL, :MSSQL, :ORACLE"}, allow_nil: true
 
         # @return [:A, :AAAA, :CNAME, :NAPTR, nil] DNS record type to associate with the GSLB virtual server's domain name.,Default value: A,Possible values = A, AAAA, CNAME, NAPTR
         attribute :dnsrecordtype
-        validates :dnsrecordtype, inclusion: {:in=>[:A, :AAAA, :CNAME, :NAPTR], :message=>"%{value} needs to be :A, :AAAA, :CNAME, :NAPTR"}, allow_nil: true
+        validates :dnsrecordtype, expression_inclusion: {:in=>[:A, :AAAA, :CNAME, :NAPTR], :message=>"%{value} needs to be :A, :AAAA, :CNAME, :NAPTR"}, allow_nil: true
 
         # @return [:ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD, nil] Load balancing method for the GSLB virtual server.,Default value: LEASTCONNECTION,Possible values = ROUNDROBIN, LEASTCONNECTION, LEASTRESPONSETIME, SOURCEIPHASH, LEASTBANDWIDTH, LEASTPACKETS, STATICPROXIMITY, RTT, CUSTOMLOAD
         attribute :lbmethod
-        validates :lbmethod, inclusion: {:in=>[:ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD], :message=>"%{value} needs to be :ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD"}, allow_nil: true
+        validates :lbmethod, expression_inclusion: {:in=>[:ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD], :message=>"%{value} needs to be :ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD"}, allow_nil: true
 
         # @return [:ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD, nil] Backup load balancing method. Becomes operational if the primary load balancing method fails or cannot be used. Valid only if the primary method is based on either round-trip time (RTT) or static proximity.
         attribute :backuplbmethod
-        validates :backuplbmethod, inclusion: {:in=>[:ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD], :message=>"%{value} needs to be :ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD"}, allow_nil: true
+        validates :backuplbmethod, expression_inclusion: {:in=>[:ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD], :message=>"%{value} needs to be :ROUNDROBIN, :LEASTCONNECTION, :LEASTRESPONSETIME, :SOURCEIPHASH, :LEASTBANDWIDTH, :LEASTPACKETS, :STATICPROXIMITY, :RTT, :CUSTOMLOAD"}, allow_nil: true
 
         # @return [Object, nil] IPv4 network mask for use in the SOURCEIPHASH load balancing method.,Minimum length = 1
         attribute :netmask
@@ -38,7 +38,7 @@ module Ansible
 
         # @return [:SOURCEIP, :NONE, nil] Use source IP address based persistence for the virtual server.,After the load balancing method selects a service for the first packet, the IP address received in response to the DNS query is used for subsequent requests from the same client.
         attribute :persistencetype
-        validates :persistencetype, inclusion: {:in=>[:SOURCEIP, :NONE], :message=>"%{value} needs to be :SOURCEIP, :NONE"}, allow_nil: true
+        validates :persistencetype, expression_inclusion: {:in=>[:SOURCEIP, :NONE], :message=>"%{value} needs to be :SOURCEIP, :NONE"}, allow_nil: true
 
         # @return [Object, nil] The persistence ID for the GSLB virtual server. The ID is a positive integer that enables GSLB sites to identify the GSLB virtual server, and is required if source IP address based or spill over based persistence is enabled on the virtual server.,Minimum value = C(0),Maximum value = C(65535)
         attribute :persistenceid
@@ -54,30 +54,30 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Include multiple IP addresses in the DNS responses sent to clients.
         attribute :mir
-        validates :mir, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :mir, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] Continue to direct traffic to the backup chain even after the primary GSLB virtual server returns to the UP state. Used when spillover is configured for the virtual server.
         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 [:SERVICECOUNT, :SERVICEWEIGHT, :DISABLED, nil] Specify if the appliance should consider the service count, service weights, or ignore both when using weight-based load balancing methods. The state of the number of services bound to the virtual server help the appliance to select the service.
         attribute :dynamicweight
-        validates :dynamicweight, inclusion: {:in=>[:SERVICECOUNT, :SERVICEWEIGHT, :DISABLED], :message=>"%{value} needs to be :SERVICECOUNT, :SERVICEWEIGHT, :DISABLED"}, allow_nil: true
+        validates :dynamicweight, expression_inclusion: {:in=>[:SERVICECOUNT, :SERVICEWEIGHT, :DISABLED], :message=>"%{value} needs to be :SERVICECOUNT, :SERVICEWEIGHT, :DISABLED"}, allow_nil: true
 
         # @return [:NONE, :STATE_ONLY, nil] If the primary state of all bound GSLB services is DOWN, consider the effective states of all the GSLB services, obtained through the Metrics Exchange Protocol (MEP), when determining the state of the GSLB virtual server. To consider the effective state, set the parameter to STATE_ONLY. To disregard the effective state, set the parameter to NONE.,The effective state of a GSLB service is the ability of the corresponding virtual server to serve traffic. The effective state of the load balancing virtual server, which is transferred to the GSLB service, is UP even if only one virtual server in the backup chain of virtual servers is in the UP state.
         attribute :considereffectivestate
-        validates :considereffectivestate, inclusion: {:in=>[:NONE, :STATE_ONLY], :message=>"%{value} needs to be :NONE, :STATE_ONLY"}, allow_nil: true
+        validates :considereffectivestate, expression_inclusion: {:in=>[:NONE, :STATE_ONLY], :message=>"%{value} needs to be :NONE, :STATE_ONLY"}, allow_nil: true
 
         # @return [Object, nil] Any comments that you might want to associate with the GSLB virtual server.
         attribute :comment
 
         # @return [:CONNECTION, :DYNAMICCONNECTION, :BANDWIDTH, :HEALTH, :NONE, nil] Type of threshold that, when exceeded, triggers spillover. Available settings function as follows:,* C(CONNECTION) - Spillover occurs when the number of client connections exceeds the threshold.,* C(DYNAMICCONNECTION) - Spillover occurs when the number of client connections at the GSLB virtual server exceeds the sum of the maximum client (Max Clients) settings for bound GSLB services. Do not specify a spillover threshold for this setting, because the threshold is implied by the Max Clients settings of the bound GSLB services.,* C(BANDWIDTH) - Spillover occurs when the bandwidth consumed by the GSLB virtual server's incoming and outgoing traffic exceeds the threshold.,* C(HEALTH) - Spillover occurs when the percentage of weights of the GSLB services that are UP drops below the threshold. For example, if services gslbSvc1, gslbSvc2, and gslbSvc3 are bound to a virtual server, with weights 1, 2, and 3, and the spillover threshold is 50%, spillover occurs if gslbSvc1 and gslbSvc3 or gslbSvc2 and gslbSvc3 transition to DOWN.,* C(NONE) - Spillover does not occur.
         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] If spillover occurs, maintain source IP address based persistence for both primary and backup GSLB 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] Timeout for spillover persistence, in minutes.,Default value: C(2),Minimum value = C(2),Maximum value = C(1440)
         attribute :sopersistencetimeout
@@ -87,11 +87,11 @@ 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] 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] List of bindings for domains for this glsb vserver.
         attribute :domain_bindings

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

@@ -25,7 +25,7 @@ module Ansible
 
         # @return [:http, :https, nil] Which protocol to use when accessing the Nitro API objects.
         attribute :nitro_protocol
-        validates :nitro_protocol, inclusion: {:in=>[:http, :https], :message=>"%{value} needs to be :http, :https"}, allow_nil: true
+        validates :nitro_protocol, expression_inclusion: {:in=>[:http, :https], :message=>"%{value} needs to be :http, :https"}, allow_nil: true
 
         # @return [String, nil] If C(no), SSL certificates will not be validated. This should only be used on personally controlled sites using self-signed certificates.
         attribute :validate_certs
@@ -57,7 +57,7 @@ module Ansible
 
         # @return [:add, :update, :get, :get_by_args, :get_filtered, :get_all, :delete, :delete_by_args, :count, :mas_login, :save_config, :action, nil] Define the Nitro operation that we want to perform.
         attribute :operation
-        validates :operation, inclusion: {:in=>[:add, :update, :get, :get_by_args, :get_filtered, :get_all, :delete, :delete_by_args, :count, :mas_login, :save_config, :action], :message=>"%{value} needs to be :add, :update, :get, :get_by_args, :get_filtered, :get_all, :delete, :delete_by_args, :count, :mas_login, :save_config, :action"}, allow_nil: true
+        validates :operation, expression_inclusion: {:in=>[:add, :update, :get, :get_by_args, :get_filtered, :get_all, :delete, :delete_by_args, :count, :mas_login, :save_config, :action], :message=>"%{value} needs to be :add, :update, :get, :get_by_args, :get_filtered, :get_all, :delete, :delete_by_args, :count, :mas_login, :save_config, :action"}, allow_nil: true
 
         # @return [Integer] A list of numeric values that signify that the operation was successful.
         attribute :expected_nitro_errorcode

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

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:http, :https, nil] Which protocol to use when accessing the nitro API objects.
         attribute :nitro_protocol
-        validates :nitro_protocol, inclusion: {:in=>[:http, :https], :message=>"%{value} needs to be :http, :https"}, allow_nil: true
+        validates :nitro_protocol, expression_inclusion: {:in=>[:http, :https], :message=>"%{value} needs to be :http, :https"}, allow_nil: true
 
         # @return [String, nil] If C(no), SSL certificates will not be validated. This should only be used on personally controlled sites using self-signed certificates.
         attribute :validate_certs

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

@@ -23,7 +23,7 @@ module Ansible
 
         # @return [:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX, nil] Protocol in which data is exchanged with the service.
         attribute :servicetype
-        validates :servicetype, inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX"}, allow_nil: true
+        validates :servicetype, expression_inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX"}, allow_nil: true
 
         # @return [Integer, nil] Port number of the service.,Range 1 - 65535,* in CLI is represented as 65535 in NITRO API
         attribute :port
@@ -34,25 +34,25 @@ module Ansible
 
         # @return [:TRANSPARENT, :REVERSE, :FORWARD, nil] Cache type supported by the cache server.
         attribute :cachetype
-        validates :cachetype, inclusion: {:in=>[:TRANSPARENT, :REVERSE, :FORWARD], :message=>"%{value} needs to be :TRANSPARENT, :REVERSE, :FORWARD"}, allow_nil: true
+        validates :cachetype, expression_inclusion: {:in=>[:TRANSPARENT, :REVERSE, :FORWARD], :message=>"%{value} needs to be :TRANSPARENT, :REVERSE, :FORWARD"}, allow_nil: true
 
         # @return [Object, nil] Maximum number of simultaneous open connections to the service.,Minimum value = 0,Maximum value = 4294967294
         attribute :maxclient
 
         # @return [Boolean, nil] Monitor the health of this service
         attribute :healthmonitor
-        validates :healthmonitor, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :healthmonitor, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Object, nil] Maximum number of requests that can be sent on a persistent connection to the service.,Note: Connection requests beyond this value are rejected.,Minimum value = 0,Maximum value = 65535
         attribute :maxreq
 
         # @return [Boolean, nil] Use the transparent cache redirection virtual server to forward requests to the cache server.,Note: Do not specify this parameter if you set the Cache Type parameter.
         attribute :cacheable
-        validates :cacheable, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :cacheable, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] Before forwarding a request to the service, insert an HTTP header with the client's IPv4 or IPv6 address as its value. Used if the server needs the client's IP address for security, accounting, or other purposes, and setting the Use Source IP parameter is not a viable option.
         attribute :cip
-        validates :cip, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :cip, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Name for the HTTP header whose value must be set to the IP address of the client. Used with the Client IP parameter. If you set the Client IP parameter, and you do not specify a name for the header, the appliance uses the header name specified for the global Client IP Header parameter (the cipHeader parameter in the set ns param CLI command or the Client IP Header parameter in the Configure HTTP Parameters dialog box at System > Settings > Change HTTP parameters). If the global Client IP Header parameter is not specified, the appliance inserts a header with the name "client-ip.".,Minimum length = 1
         attribute :cipheader
@@ -74,7 +74,7 @@ module Ansible
 
         # @return [Boolean, nil] Enable RTSP session ID mapping for the service.
         attribute :rtspsessionidremap
-        validates :rtspsessionidremap, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :rtspsessionidremap, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Object, nil] Time, in seconds, after which to terminate an idle client connection.,Minimum value = 0,Maximum value = 31536000
         attribute :clttimeout
@@ -102,14 +102,14 @@ module Ansible
 
         # @return [Boolean, nil] Use Layer 2 mode to bridge the packets sent to this service if it is marked as DOWN. If the service is DOWN, and this parameter is disabled, the packets are dropped.
         attribute :accessdown
-        validates :accessdown, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :accessdown, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Object, nil] Minimum sum of weights of the monitors that are bound to this service. Used to determine whether to mark a service as UP or DOWN.,Minimum value = 0,Maximum value = 65535
         attribute :monthreshold
 
         # @return [:enabled, :disabled, nil] Flush all active transactions associated with a service 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 TCP profile that contains TCP configuration settings for the service.,Minimum length = 1,Maximum length = 127
         attribute :tcpprofilename
@@ -125,7 +125,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Enable logging of AppFlow 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] Network profile to use for the service.,Minimum length = 1,Maximum length = 127
         attribute :netprofile
@@ -135,7 +135,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] By turning on this option packets destined to a service in a cluster will not under go any steering. Turn this option for single packet request response mode or when the upstream device is performing a proper RSS for connection based distribution.
         attribute :processlocal
-        validates :processlocal, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :processlocal, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Name of the DNS profile to be associated with the service. DNS profile properties will applied to the transactions processed by a service. This parameter is valid only for ADNS and ADNS-TCP services.,Minimum length = 1,Maximum length = 127
         attribute :dnsprofilename
@@ -146,7 +146,7 @@ module Ansible
 
         # @return [Boolean, nil] Shut down gracefully, not accepting any new connections, and disabling the service when all of its connections are closed.
         attribute :graceful
-        validates :graceful, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :graceful, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Array<String>, String, nil] A list of load balancing monitors to bind to this service.,Each monitor entry is a dictionary which may contain the following options.,Note that if not using the built in monitors they must first be setup.
         attribute :monitor_bindings

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

@@ -15,11 +15,11 @@ module Ansible
 
         # @return [:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX, nil] Protocol used to exchange data with the service.
         attribute :servicetype
-        validates :servicetype, inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX"}, allow_nil: true
+        validates :servicetype, expression_inclusion: {:in=>[:HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX], :message=>"%{value} needs to be :HTTP, :FTP, :TCP, :UDP, :SSL, :SSL_BRIDGE, :SSL_TCP, :DTLS, :NNTP, :RPCSVR, :DNS, :ADNS, :SNMP, :RTSP, :DHCPRA, :ANY, :SIP_UDP, :SIP_TCP, :SIP_SSL, :DNS_TCP, :ADNS_TCP, :MYSQL, :MSSQL, :ORACLE, :RADIUS, :RADIUSListener, :RDP, :DIAMETER, :SSL_DIAMETER, :TFTP, :SMPP, :PPTP, :GRE, :SYSLOGTCP, :SYSLOGUDP, :FIX, :SSL_FIX"}, allow_nil: true
 
         # @return [:TRANSPARENT, :REVERSE, :FORWARD, nil] Cache type supported by the cache server.
         attribute :cachetype
-        validates :cachetype, inclusion: {:in=>[:TRANSPARENT, :REVERSE, :FORWARD], :message=>"%{value} needs to be :TRANSPARENT, :REVERSE, :FORWARD"}, allow_nil: true
+        validates :cachetype, expression_inclusion: {:in=>[:TRANSPARENT, :REVERSE, :FORWARD], :message=>"%{value} needs to be :TRANSPARENT, :REVERSE, :FORWARD"}, allow_nil: true
 
         # @return [Object, nil] Maximum number of simultaneous open connections for the service group.,Minimum value = C(0),Maximum value = C(4294967294)
         attribute :maxclient
@@ -33,7 +33,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Insert the Client IP header in requests forwarded to the service.
         attribute :cip
-        validates :cip, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :cip, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Name of the HTTP header whose value must be set to the IP address of the client. Used with the Client IP parameter. If client IP insertion is enabled, and the client IP header is not specified, the value of Client IP Header parameter or the value set by the set ns config command is used as client's IP header name.,Minimum length = 1
         attribute :cipheader
@@ -89,7 +89,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Flush all active transactions associated with all the services in the service group 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 TCP profile that contains TCP configuration settings for the service group.,Minimum length = 1,Maximum length = 127
         attribute :tcpprofilename
@@ -102,14 +102,14 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Enable logging of AppFlow information for the specified service group.
         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] Network profile for the service group.,Minimum length = 1,Maximum length = 127
         attribute :netprofile
 
         # @return [:DISABLED, :DNS, :POLICY, nil] Auto scale option for a servicegroup.
         attribute :autoscale
-        validates :autoscale, inclusion: {:in=>[:DISABLED, :DNS, :POLICY], :message=>"%{value} needs to be :DISABLED, :DNS, :POLICY"}, allow_nil: true
+        validates :autoscale, expression_inclusion: {:in=>[:DISABLED, :DNS, :POLICY], :message=>"%{value} needs to be :DISABLED, :DNS, :POLICY"}, allow_nil: true
 
         # @return [Object, nil] member port.
         attribute :memberport

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

@@ -22,11 +22,11 @@ module Ansible
 
         # @return [Boolean, nil] Passphrase that was used to encrypt the private-key. Use this option to load encrypted private-keys in PEM format.
         attribute :password
-        validates :password, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :password, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [:DER, :PEM, :PFX, nil] Input format of the certificate and the private-key files. The three formats supported by the appliance are:,PEM - Privacy Enhanced Mail,DER - Distinguished Encoding Rule,PFX - Personal Information Exchange.
         attribute :inform
-        validates :inform, inclusion: {:in=>[:DER, :PEM, :PFX], :message=>"%{value} needs to be :DER, :PEM, :PFX"}, allow_nil: true
+        validates :inform, expression_inclusion: {:in=>[:DER, :PEM, :PFX], :message=>"%{value} needs to be :DER, :PEM, :PFX"}, allow_nil: true
 
         # @return [String, nil] Pass phrase used to encrypt the private-key. Required when adding an encrypted private-key in PEM format.,Minimum length = 1
         attribute :passplain
@@ -34,7 +34,7 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Issue an alert when the certificate is about to expire.
         attribute :expirymonitor
-        validates :expirymonitor, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :expirymonitor, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Integer, nil] Time, in number of days, before certificate expiration, at which to generate an alert that the certificate is about to expire.,Minimum value = C(10),Maximum value = C(100)
         attribute :notificationperiod

data/lib/ansible/ruby/modules/generated/network/netvisor/pn_cluster.rb

@@ -20,7 +20,7 @@ module Ansible
 
         # @return [:present, :absent] Specify action to perform. Use 'present' to create cluster and 'absent' to delete cluster.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}
 
         # @return [String] Specify the name of the cluster.
         attribute :pn_name
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [:validate, :"no-validate", nil] Validate the inter-switch links and state of switches in the cluster.
         attribute :pn_validate
-        validates :pn_validate, inclusion: {:in=>[:validate, :"no-validate"], :message=>"%{value} needs to be :validate, :\"no-validate\""}, allow_nil: true
+        validates :pn_validate, expression_inclusion: {:in=>[:validate, :"no-validate"], :message=>"%{value} needs to be :validate, :\"no-validate\""}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/netvisor/pn_ospf.rb

@@ -20,7 +20,7 @@ module Ansible
 
         # @return [:present, :absent] Assert the state of the ospf. Use 'present' to add ospf and 'absent' to remove ospf.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}
 
         # @return [String] Specify the name of the vRouter.
         attribute :pn_vrouter_name

data/lib/ansible/ruby/modules/generated/network/netvisor/pn_ospfarea.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:present, :absent, :update] State the action to perform. Use 'present' to add ospf-area, 'absent' to remove ospf-area and 'update' to modify ospf-area.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :absent, :update], :message=>"%{value} needs to be :present, :absent, :update"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :absent, :update], :message=>"%{value} needs to be :present, :absent, :update"}
 
         # @return [String] Specify the name of the vRouter.
         attribute :pn_vrouter_name
@@ -34,7 +34,7 @@ module Ansible
 
         # @return [:none, :stub, :"stub-no-summary", :nssa, :"nssa-no-summary", nil] Specify the OSPF stub type.
         attribute :pn_stub_type
-        validates :pn_stub_type, inclusion: {:in=>[:none, :stub, :"stub-no-summary", :nssa, :"nssa-no-summary"], :message=>"%{value} needs to be :none, :stub, :\"stub-no-summary\", :nssa, :\"nssa-no-summary\""}, allow_nil: true
+        validates :pn_stub_type, expression_inclusion: {:in=>[:none, :stub, :"stub-no-summary", :nssa, :"nssa-no-summary"], :message=>"%{value} needs to be :none, :stub, :\"stub-no-summary\", :nssa, :\"nssa-no-summary\""}, allow_nil: true
 
         # @return [Object, nil] OSPF prefix list for filtering incoming packets.
         attribute :pn_prefix_listin
@@ -44,7 +44,7 @@ module Ansible
 
         # @return [Boolean, nil] Enable/disable system information.
         attribute :pn_quiet
-        validates :pn_quiet, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :pn_quiet, 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/netvisor/pn_trunk.rb

@@ -20,7 +20,7 @@ module Ansible
 
         # @return [:present, :absent, :update] State the action to perform. Use 'present' to create trunk, 'absent' to delete trunk and 'update' to modify trunk.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :absent, :update], :message=>"%{value} needs to be :present, :absent, :update"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :absent, :update], :message=>"%{value} needs to be :present, :absent, :update"}
 
         # @return [String] Specify the name for the trunk configuration.
         attribute :pn_name
@@ -32,7 +32,7 @@ module Ansible
 
         # @return [:disable, :"10m", :"100m", :"1g", :"2.5g", :"10g", :"40g", nil] Specify the port speed or disable the port.
         attribute :pn_speed
-        validates :pn_speed, inclusion: {:in=>[:disable, :"10m", :"100m", :"1g", :"2.5g", :"10g", :"40g"], :message=>"%{value} needs to be :disable, :\"10m\", :\"100m\", :\"1g\", :\"2.5g\", :\"10g\", :\"40g\""}, allow_nil: true
+        validates :pn_speed, expression_inclusion: {:in=>[:disable, :"10m", :"100m", :"1g", :"2.5g", :"10g", :"40g"], :message=>"%{value} needs to be :disable, :\"10m\", :\"100m\", :\"1g\", :\"2.5g\", :\"10g\", :\"40g\""}, allow_nil: true
 
         # @return [Object, nil] Specify an egress port data rate limit for the configuration.
         attribute :pn_egress_rate_limit
@@ -42,18 +42,18 @@ module Ansible
 
         # @return [:off, :passive, :active, nil] Specify the LACP mode for the configuration.
         attribute :pn_lacp_mode
-        validates :pn_lacp_mode, inclusion: {:in=>[:off, :passive, :active], :message=>"%{value} needs to be :off, :passive, :active"}, allow_nil: true
+        validates :pn_lacp_mode, expression_inclusion: {:in=>[:off, :passive, :active], :message=>"%{value} needs to be :off, :passive, :active"}, allow_nil: true
 
         # @return [Object, nil] Specify the LACP priority. This is a number between 1 and 65535 with a default value of 32768.
         attribute :pn_lacp_priority
 
         # @return [:slow, :fast, nil] Specify the LACP time out as slow (30 seconds) or fast (4seconds). The default value is slow.
         attribute :pn_lacp_timeout
-        validates :pn_lacp_timeout, inclusion: {:in=>[:slow, :fast], :message=>"%{value} needs to be :slow, :fast"}, allow_nil: true
+        validates :pn_lacp_timeout, expression_inclusion: {:in=>[:slow, :fast], :message=>"%{value} needs to be :slow, :fast"}, allow_nil: true
 
         # @return [:bundle, :individual, nil] Specify the LACP fallback mode as bundles or individual.
         attribute :pn_lacp_fallback
-        validates :pn_lacp_fallback, inclusion: {:in=>[:bundle, :individual], :message=>"%{value} needs to be :bundle, :individual"}, allow_nil: true
+        validates :pn_lacp_fallback, expression_inclusion: {:in=>[:bundle, :individual], :message=>"%{value} needs to be :bundle, :individual"}, allow_nil: true
 
         # @return [Object, nil] Specify the LACP fallback timeout in seconds. The range is between 30 and 60 seconds with a default value of 50 seconds.
         attribute :pn_lacp_fallback_timeout

data/lib/ansible/ruby/modules/generated/network/netvisor/pn_vlag.rb

@@ -20,7 +20,7 @@ module Ansible
 
         # @return [:present, :absent, :update] State the action to perform. Use 'present' to create vlag, 'absent' to delete vlag and 'update' to modify vlag.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :absent, :update], :message=>"%{value} needs to be :present, :absent, :update"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :absent, :update], :message=>"%{value} needs to be :present, :absent, :update"}
 
         # @return [String] The C(pn_name) takes a valid name for vlag configuration.
         attribute :pn_name
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [:"active-active", :"active-standby", nil] Specify the mode for the VLAG. Active-standby indicates one side is active and the other side is in standby mode. Active-active indicates that both sides of the vlag are up by default.
         attribute :pn_mode
-        validates :pn_mode, inclusion: {:in=>[:"active-active", :"active-standby"], :message=>"%{value} needs to be :\"active-active\", :\"active-standby\""}, allow_nil: true
+        validates :pn_mode, expression_inclusion: {:in=>[:"active-active", :"active-standby"], :message=>"%{value} needs to be :\"active-active\", :\"active-standby\""}, allow_nil: true
 
         # @return [String, nil] Specify the fabric-name of the peer switch.
         attribute :pn_peer_switch
@@ -44,19 +44,19 @@ module Ansible
 
         # @return [:move, :ignore, nil] Specify the failover action as move or ignore.
         attribute :pn_failover_action
-        validates :pn_failover_action, inclusion: {:in=>[:move, :ignore], :message=>"%{value} needs to be :move, :ignore"}, allow_nil: true
+        validates :pn_failover_action, expression_inclusion: {:in=>[:move, :ignore], :message=>"%{value} needs to be :move, :ignore"}, allow_nil: true
 
         # @return [:off, :passive, :active, nil] Specify the LACP mode.
         attribute :pn_lacp_mode
-        validates :pn_lacp_mode, inclusion: {:in=>[:off, :passive, :active], :message=>"%{value} needs to be :off, :passive, :active"}, allow_nil: true
+        validates :pn_lacp_mode, expression_inclusion: {:in=>[:off, :passive, :active], :message=>"%{value} needs to be :off, :passive, :active"}, allow_nil: true
 
         # @return [:slow, :fast, nil] Specify the LACP timeout as slow(30 seconds) or fast(4 seconds).
         attribute :pn_lacp_timeout
-        validates :pn_lacp_timeout, inclusion: {:in=>[:slow, :fast], :message=>"%{value} needs to be :slow, :fast"}, allow_nil: true
+        validates :pn_lacp_timeout, expression_inclusion: {:in=>[:slow, :fast], :message=>"%{value} needs to be :slow, :fast"}, allow_nil: true
 
         # @return [:bundle, :individual, nil] Specify the LACP fallback mode as bundles or individual.
         attribute :pn_lacp_fallback
-        validates :pn_lacp_fallback, inclusion: {:in=>[:bundle, :individual], :message=>"%{value} needs to be :bundle, :individual"}, allow_nil: true
+        validates :pn_lacp_fallback, expression_inclusion: {:in=>[:bundle, :individual], :message=>"%{value} needs to be :bundle, :individual"}, allow_nil: true
 
         # @return [Object, nil] Specify the LACP fallback timeout in seconds. The range is between 30 and 60 seconds with a default value of 50 seconds.
         attribute :pn_lacp_fallback_timeout