ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_bgp_neighbor.rb

@@ -10,7 +10,7 @@ module Ansible
       class Ce_bgp_neighbor < Base
         # @return [:present, :absent, nil] Specify desired state of the resource.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [Object] Name of a BGP instance. The name is a case-sensitive string of characters. The BGP instance can be used only after the corresponding VPN instance is created.
         attribute :vrf_name
@@ -32,19 +32,19 @@ module Ansible
 
         # @return [:no_use, :true, :false, nil] If the value is true, the EBGP peer can use either a fake AS number or the actual AS number. If the value is false, the EBGP peer can only use a fake AS number.
         attribute :dual_as
-        validates :dual_as, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :dual_as, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the router has all extended capabilities. If the value is false, the router does not have all extended capabilities.
         attribute :conventional
-        validates :conventional, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :conventional, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, BGP is enabled to advertise REFRESH packets. If the value is false, the route refresh function is enabled.
         attribute :route_refresh
-        validates :route_refresh, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :route_refresh, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the session with a specified peer is torn down and all related routing entries are cleared. If the value is false, the session with a specified peer is retained.
         attribute :is_ignore
-        validates :is_ignore, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :is_ignore, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] Name of a source interface that sends BGP packets. The value is a string of 1 to 63 characters.
         attribute :local_if_name
@@ -60,11 +60,11 @@ module Ansible
 
         # @return [:no_use, :true, :false, nil] If the value is true, BGP is enabled to record peer session status and event information. If the value is false, BGP is disabled from recording peer session status and event information.
         attribute :is_log_change
-        validates :is_log_change, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :is_log_change, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:null, :cipher, :simple, nil] Enable BGP peers to establish a TCP connection and perform the Message Digest 5 (MD5) authentication for BGP messages.
         attribute :pswd_type
-        validates :pswd_type, inclusion: {:in=>[:null, :cipher, :simple], :message=>"%{value} needs to be :null, :cipher, :simple"}, allow_nil: true
+        validates :pswd_type, expression_inclusion: {:in=>[:null, :cipher, :simple], :message=>"%{value} needs to be :null, :cipher, :simple"}, allow_nil: true
 
         # @return [Object, nil] The character string in a password identifies the contents of the password, spaces not supported. The value is a string of 1 to 255 characters.
         attribute :pswd_cipher_text
@@ -89,26 +89,26 @@ module Ansible
 
         # @return [:no_use, :true, :false, nil] If the value is true, peer create MPLS Local IFNET disable. If the value is false, peer create MPLS Local IFNET enable.
         attribute :mpls_local_ifnet_disable
-        validates :mpls_local_ifnet_disable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :mpls_local_ifnet_disable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] Add the global AS number to the Update packets to be advertised.
         attribute :prepend_global_as
-        validates :prepend_global_as, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :prepend_global_as, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] Add the Fake AS number to received Update packets.
         attribute :prepend_fake_as
-        validates :prepend_fake_as, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :prepend_fake_as, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, peers are enabled to inherit the BFD function from the peer group. If the value is false, peers are disabled to inherit the BFD function from the peer group.
         attribute :is_bfd_block
-        validates :is_bfd_block, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :is_bfd_block, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] Specify the detection multiplier. The default value is 3. The value is an integer ranging from 3 to 50.
         attribute :multiplier
 
         # @return [:no_use, :true, :false, nil] If the value is true, BFD is enabled. If the value is false, BFD is disabled.
         attribute :is_bfd_enable
-        validates :is_bfd_enable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :is_bfd_enable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] Specify the minimum interval at which BFD packets are received. The value is an integer ranging from 50 to 1000, in milliseconds.
         attribute :rx_interval
@@ -118,7 +118,7 @@ module Ansible
 
         # @return [:no_use, :true, :false, nil] If the value is true, the system is enabled to preferentially use the single-hop mode for BFD session setup between IBGP peers. If the value is false, the system is disabled from preferentially using the single-hop mode for BFD session setup between IBGP peers.
         attribute :is_single_hop
-        validates :is_single_hop, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :is_single_hop, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_bgp_neighbor_af.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:ipv4uni, :ipv4multi, :ipv4vpn, :ipv6uni, :ipv6vpn, :evpn] Address family type of a BGP instance.
         attribute :af_type
-        validates :af_type, presence: true, inclusion: {:in=>[:ipv4uni, :ipv4multi, :ipv4vpn, :ipv6uni, :ipv6vpn, :evpn], :message=>"%{value} needs to be :ipv4uni, :ipv4multi, :ipv4vpn, :ipv6uni, :ipv6vpn, :evpn"}
+        validates :af_type, presence: true, expression_inclusion: {:in=>[:ipv4uni, :ipv4multi, :ipv4vpn, :ipv6uni, :ipv6vpn, :evpn], :message=>"%{value} needs to be :ipv4uni, :ipv4multi, :ipv4vpn, :ipv6uni, :ipv6vpn, :evpn"}
 
         # @return [Object] IPv4 or IPv6 peer connection address.
         attribute :remote_address
@@ -22,65 +22,65 @@ module Ansible
 
         # @return [:no_use, :true, :false, nil] If the value is true, advertised IRB routes are distinguished. If the value is false, advertised IRB routes are not distinguished.
         attribute :advertise_irb
-        validates :advertise_irb, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :advertise_irb, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, advertised ARP routes are distinguished. If the value is false, advertised ARP routes are not distinguished.
         attribute :advertise_arp
-        validates :advertise_arp, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :advertise_arp, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the remote next-hop attribute is advertised to peers. If the value is false, the remote next-hop attribute is not advertised to any peers.
         attribute :advertise_remote_nexthop
-        validates :advertise_remote_nexthop, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :advertise_remote_nexthop, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the community attribute is advertised to peers. If the value is false, the community attribute is not advertised to peers.
         attribute :advertise_community
-        validates :advertise_community, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :advertise_community, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the extended community attribute is advertised to peers. If the value is false, the extended community attribute is not advertised to peers.
         attribute :advertise_ext_community
-        validates :advertise_ext_community, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :advertise_ext_community, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the extended community attribute in the peer route information is discarded. If the value is false, the extended community attribute in the peer route information is not discarded.
         attribute :discard_ext_community
-        validates :discard_ext_community, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :discard_ext_community, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, repetitive local AS numbers are allowed. If the value is false, repetitive local AS numbers are not allowed.
         attribute :allow_as_loop_enable
-        validates :allow_as_loop_enable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :allow_as_loop_enable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] Set the maximum number of repetitive local AS number. The value is an integer ranging from 1 to 10.
         attribute :allow_as_loop_limit
 
         # @return [:no_use, :true, :false, nil] If the value is true, the system stores all route update messages received from all peers (groups) after BGP connection setup. If the value is false, the system stores only BGP update messages that are received from peers and pass the configured import policy.
         attribute :keep_all_routes
-        validates :keep_all_routes, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :keep_all_routes, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:null, :local, :invariable, nil] null, The next hop is not changed. local, The next hop is changed to the local IP address. invariable, Prevent the device from changing the next hop of each imported IGP route when advertising it to its BGP peers.
         attribute :nexthop_configure
-        validates :nexthop_configure, inclusion: {:in=>[:null, :local, :invariable], :message=>"%{value} needs to be :null, :local, :invariable"}, allow_nil: true
+        validates :nexthop_configure, expression_inclusion: {:in=>[:null, :local, :invariable], :message=>"%{value} needs to be :null, :local, :invariable"}, allow_nil: true
 
         # @return [Object, nil] Assign a preferred value for the routes learned from a specified peer. The value is an integer ranging from 0 to 65535.
         attribute :preferred_value
 
         # @return [:no_use, :true, :false, nil] If the value is true, sent BGP update messages carry only the public AS number but do not carry private AS numbers. If the value is false, sent BGP update messages can carry private AS numbers.
         attribute :public_as_only
-        validates :public_as_only, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :public_as_only, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, sent BGP update messages carry only the public AS number but do not carry private AS numbers. If the value is false, sent BGP update messages can carry private AS numbers.
         attribute :public_as_only_force
-        validates :public_as_only_force, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :public_as_only_force, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] Limited use public as number.
         attribute :public_as_only_limited
-        validates :public_as_only_limited, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :public_as_only_limited, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] Private as replaced by public as number.
         attribute :public_as_only_replace
-        validates :public_as_only_replace, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :public_as_only_replace, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] Public as only skip peer as.
         attribute :public_as_only_skip_peer_as
-        validates :public_as_only_skip_peer_as, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :public_as_only_skip_peer_as, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] Configure the maximum number of routes that can be accepted from a peer. The value is an integer ranging from 1 to 4294967295.
         attribute :route_limit
@@ -90,7 +90,7 @@ module Ansible
 
         # @return [:noparameter, :alertOnly, :idleForever, :idleTimeout, nil] Noparameter, After the number of received routes exceeds the threshold and the timeout timer expires,no action. AlertOnly, An alarm is generated and no additional routes will be accepted if the maximum number of routes allowed have been received. IdleForever, The connection that is interrupted is not automatically re-established if the maximum number of routes allowed have been received. IdleTimeout, After the number of received routes exceeds the threshold and the timeout timer expires, the connection that is interrupted is automatically re-established.
         attribute :route_limit_type
-        validates :route_limit_type, inclusion: {:in=>[:noparameter, :alertOnly, :idleForever, :idleTimeout], :message=>"%{value} needs to be :noparameter, :alertOnly, :idleForever, :idleTimeout"}, allow_nil: true
+        validates :route_limit_type, expression_inclusion: {:in=>[:noparameter, :alertOnly, :idleForever, :idleTimeout], :message=>"%{value} needs to be :noparameter, :alertOnly, :idleForever, :idleTimeout"}, allow_nil: true
 
         # @return [Object, nil] Specify the value of the idle-timeout timer to automatically reestablish the connections after they are cut off when the number of routes exceeds the set threshold. The value is an integer ranging from 1 to 1200.
         attribute :route_limit_idle_timeout
@@ -100,19 +100,19 @@ module Ansible
 
         # @return [:no_use, :true, :false, nil] Redirect ip.
         attribute :redirect_ip
-        validates :redirect_ip, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :redirect_ip, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] Redirect ip vaildation.
         attribute :redirect_ip_vaildation
-        validates :redirect_ip_vaildation, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :redirect_ip_vaildation, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the local device functions as the route reflector and a peer functions as a client of the route reflector. If the value is false, the route reflector and client functions are not configured.
         attribute :reflect_client
-        validates :reflect_client, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :reflect_client, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, the function to replace a specified peer's AS number in the AS-Path attribute with the local AS number is enabled. If the value is false, the function to replace a specified peer's AS number in the AS-Path attribute with the local AS number is disabled.
         attribute :substitute_as_enable
-        validates :substitute_as_enable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :substitute_as_enable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] Specify the filtering policy applied to the routes learned from a peer. The value is a string of 1 to 40 characters.
         attribute :import_rt_policy_name
@@ -146,55 +146,55 @@ module Ansible
 
         # @return [:no_use, :true, :false, nil] If the value is true, the address prefix-based Outbound Route Filter (ORF) capability is enabled for peers. If the value is false, the address prefix-based Outbound Route Filter (ORF) capability is disabled for peers.
         attribute :ipprefix_orf_enable
-        validates :ipprefix_orf_enable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :ipprefix_orf_enable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, Non-standard capability codes are used during capability negotiation. If the value is false, RFC-defined standard ORF capability codes are used during capability negotiation.
         attribute :is_nonstd_ipprefix_mod
-        validates :is_nonstd_ipprefix_mod, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :is_nonstd_ipprefix_mod, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] ORF Type. The value is an integer ranging from 0 to 65535.
         attribute :orftype
 
         # @return [:null, :receive, :send, :both, nil] ORF mode. null, Default value. receive, ORF for incoming packets. send, ORF for outgoing packets. both, ORF for incoming and outgoing packets.
         attribute :orf_mode
-        validates :orf_mode, inclusion: {:in=>[:null, :receive, :send, :both], :message=>"%{value} needs to be :null, :receive, :send, :both"}, allow_nil: true
+        validates :orf_mode, expression_inclusion: {:in=>[:null, :receive, :send, :both], :message=>"%{value} needs to be :null, :receive, :send, :both"}, allow_nil: true
 
         # @return [Object, nil] Configure the Site-of-Origin (SoO) extended community attribute. The value is a string of 3 to 21 characters.
         attribute :soostring
 
         # @return [:no_use, :true, :false, nil] If the value is true, the function to advertise default routes to peers is enabled. If the value is false, the function to advertise default routes to peers is disabled.
         attribute :default_rt_adv_enable
-        validates :default_rt_adv_enable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :default_rt_adv_enable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [Object, nil] Specify the name of a used policy. The value is a string. The value is a string of 1 to 40 characters.
         attribute :default_rt_adv_policy
 
         # @return [:null, :matchall, :matchany, nil] null, Null. matchall, Advertise the default route if all matching conditions are met. matchany, Advertise the default route if any matching condition is met.
         attribute :default_rt_match_mode
-        validates :default_rt_match_mode, inclusion: {:in=>[:null, :matchall, :matchany], :message=>"%{value} needs to be :null, :matchall, :matchany"}, allow_nil: true
+        validates :default_rt_match_mode, expression_inclusion: {:in=>[:null, :matchall, :matchany], :message=>"%{value} needs to be :null, :matchall, :matchany"}, allow_nil: true
 
         # @return [:null, :receive, :send, :both, nil] null, Null. receive, Support receiving Add-Path routes. send, Support sending Add-Path routes. both, Support receiving and sending Add-Path routes.
         attribute :add_path_mode
-        validates :add_path_mode, inclusion: {:in=>[:null, :receive, :send, :both], :message=>"%{value} needs to be :null, :receive, :send, :both"}, allow_nil: true
+        validates :add_path_mode, expression_inclusion: {:in=>[:null, :receive, :send, :both], :message=>"%{value} needs to be :null, :receive, :send, :both"}, allow_nil: true
 
         # @return [Object, nil] The number of addPath advertise route. The value is an integer ranging from 2 to 64.
         attribute :adv_add_path_num
 
         # @return [:no_use, :true, :false, nil] If the value is true, Application results of route announcement. If the value is false, Routing application results are not notified.
         attribute :origin_as_valid
-        validates :origin_as_valid, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :origin_as_valid, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, vpls enable. If the value is false, vpls disable.
         attribute :vpls_enable
-        validates :vpls_enable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :vpls_enable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, enable vpls-ad. If the value is false, disable vpls-ad.
         attribute :vpls_ad_disable
-        validates :vpls_ad_disable, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :vpls_ad_disable, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
 
         # @return [:no_use, :true, :false, nil] If the value is true, When the vpnv4 multicast neighbor receives and updates the message, the message has no label. If the value is false, When the vpnv4 multicast neighbor receives and updates the message, the message has label.
         attribute :update_pkt_standard_compatible
-        validates :update_pkt_standard_compatible, inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
+        validates :update_pkt_standard_compatible, expression_inclusion: {:in=>[:no_use, :true, :false], :message=>"%{value} needs to be :no_use, :true, :false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_config.rb

@@ -25,26 +25,26 @@ module Ansible
 
         # @return [:line, :strict, :exact, :none, nil] Instructs the module on the way to perform the matching of the set of commands against the current device config.  If match is set to I(line), commands are matched line by line.  If match is set to I(strict), command lines are matched with respect to position.  If match is set to I(exact), command lines must be an equal match.  Finally, if match is set to I(none), the module will not attempt to compare the source configuration with the current-configuration on the remote device.
         attribute :match
-        validates :match, inclusion: {:in=>[:line, :strict, :exact, :none], :message=>"%{value} needs to be :line, :strict, :exact, :none"}, allow_nil: true
+        validates :match, expression_inclusion: {:in=>[:line, :strict, :exact, :none], :message=>"%{value} needs to be :line, :strict, :exact, :none"}, allow_nil: true
 
         # @return [:line, :block, nil] Instructs the module on the way to perform the configuration on the device.  If the replace argument is set to I(line) then the modified lines are pushed to the device in configuration mode.  If the replace argument is set to I(block) then the entire command block is pushed to the device in configuration mode if any line is not correct.
         attribute :replace
-        validates :replace, inclusion: {:in=>[:line, :block], :message=>"%{value} needs to be :line, :block"}, allow_nil: true
+        validates :replace, expression_inclusion: {:in=>[:line, :block], :message=>"%{value} needs to be :line, :block"}, allow_nil: true
 
         # @return [:yes, :no, nil] This argument will cause the module to create a full backup of the current C(current-configuration) from the remote device before any changes are made.  The backup file is written to the C(backup) folder in the playbook root directory.  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 [Object, nil] The module, by default, will connect to the remote device and retrieve the current current-configuration to use as a base for comparing against the contents of source.  There are times when it is not desirable to have the task get the current-configuration for every task in a playbook.  The I(config) argument allows the implementer to pass in the configuration to use as the base config for comparison.
         attribute :config
 
         # @return [:yes, :no, nil] The I(defaults) argument will influence how the current-configuration is collected from the device.  When the value is set to true, the command used to collect the current-configuration is append with the all keyword.  When the value is set to false, the command is issued without the all keyword.
         attribute :defaults
-        validates :defaults, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :defaults, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] The C(save) argument instructs the module to save the current-configuration to saved-configuration.  This operation is performed after any changes are made to the current running config.  If no changes are made, the configuration is still saved to the startup config.  This option will always cause the module to return changed.
         attribute :save
-        validates :save, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :save, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_dldp.rb

@@ -10,25 +10,25 @@ module Ansible
       class Ce_dldp < Base
         # @return [:enable, :disable, nil] Set global DLDP enable state.
         attribute :enable
-        validates :enable, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :enable, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [:enhance, :normal, nil] Set global DLDP work-mode.
         attribute :work_mode
-        validates :work_mode, inclusion: {:in=>[:enhance, :normal], :message=>"%{value} needs to be :enhance, :normal"}, allow_nil: true
+        validates :work_mode, expression_inclusion: {:in=>[:enhance, :normal], :message=>"%{value} needs to be :enhance, :normal"}, allow_nil: true
 
         # @return [Object, nil] Specifies the interval for sending Advertisement packets. The value is an integer ranging from 1 to 100, in seconds. The default interval for sending Advertisement packets is 5 seconds.
         attribute :time_internal
 
         # @return [:md5, :simple, :sha, :"hmac-sha256", :none, nil] Specifies authentication algorithm of DLDP.
         attribute :auth_mode
-        validates :auth_mode, inclusion: {:in=>[:md5, :simple, :sha, :"hmac-sha256", :none], :message=>"%{value} needs to be :md5, :simple, :sha, :\"hmac-sha256\", :none"}, allow_nil: true
+        validates :auth_mode, expression_inclusion: {:in=>[:md5, :simple, :sha, :"hmac-sha256", :none], :message=>"%{value} needs to be :md5, :simple, :sha, :\"hmac-sha256\", :none"}, allow_nil: true
 
         # @return [Object, nil] Specifies authentication password. The value is a string of 1 to 16 case-sensitive plaintexts or 24/32/48/108/128 case-sensitive encrypted characters. The string excludes a question mark (?).
         attribute :auth_pwd
 
         # @return [:enable, :disable, nil] Specify whether reset DLDP state of disabled interfaces.
         attribute :reset
-        validates :reset, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :reset, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_dldp_interface.rb

@@ -14,22 +14,22 @@ module Ansible
 
         # @return [:enable, :disable, nil] Set interface DLDP enable state.
         attribute :enable
-        validates :enable, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :enable, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [:enable, :disable, nil] Set DLDP compatible-mode enable state.
         attribute :mode_enable
-        validates :mode_enable, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :mode_enable, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [Object, nil] Set the source MAC address for DLDP packets sent in the DLDP-compatible mode. The value of MAC address is in H-H-H format. H contains 1 to 4 hexadecimal digits.
         attribute :local_mac
 
         # @return [:enable, :disable, nil] Specify whether reseting interface DLDP state.
         attribute :reset
-        validates :reset, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :reset, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [:present, :absent, nil] Manage the state of the resource.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_eth_trunk.rb

@@ -14,25 +14,25 @@ module Ansible
 
         # @return [:manual, :"lacp-dynamic", :"lacp-static", nil] Specifies the working mode of an Eth-Trunk interface.
         attribute :mode
-        validates :mode, inclusion: {:in=>[:manual, :"lacp-dynamic", :"lacp-static"], :message=>"%{value} needs to be :manual, :\"lacp-dynamic\", :\"lacp-static\""}, allow_nil: true
+        validates :mode, expression_inclusion: {:in=>[:manual, :"lacp-dynamic", :"lacp-static"], :message=>"%{value} needs to be :manual, :\"lacp-dynamic\", :\"lacp-static\""}, allow_nil: true
 
         # @return [Object, nil] Specifies the minimum number of Eth-Trunk member links in the Up state. The value is an integer ranging from 1 to the maximum number of interfaces that can be added to a Eth-Trunk interface.
         attribute :min_links
 
         # @return [:"src-dst-ip", :"src-dst-mac", :enhanced, :"dst-ip", :"dst-mac", :"src-ip", :"src-mac", nil] Hash algorithm used for load balancing among Eth-Trunk member interfaces.
         attribute :hash_type
-        validates :hash_type, inclusion: {:in=>[:"src-dst-ip", :"src-dst-mac", :enhanced, :"dst-ip", :"dst-mac", :"src-ip", :"src-mac"], :message=>"%{value} needs to be :\"src-dst-ip\", :\"src-dst-mac\", :enhanced, :\"dst-ip\", :\"dst-mac\", :\"src-ip\", :\"src-mac\""}, allow_nil: true
+        validates :hash_type, expression_inclusion: {:in=>[:"src-dst-ip", :"src-dst-mac", :enhanced, :"dst-ip", :"dst-mac", :"src-ip", :"src-mac"], :message=>"%{value} needs to be :\"src-dst-ip\", :\"src-dst-mac\", :enhanced, :\"dst-ip\", :\"dst-mac\", :\"src-ip\", :\"src-mac\""}, allow_nil: true
 
         # @return [Object, nil] List of interfaces that will be managed in a given Eth-Trunk. The interface name must be full name.
         attribute :members
 
         # @return [:yes, :no, nil] When true it forces Eth-Trunk members to match what is declared in the members param. This can be used to remove members.
         attribute :force
-        validates :force, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :force, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:present, :absent, nil] Manage the state of the resource.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_evpn_bd_vni.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:enable, :disable, nil] Create or delete an EVPN instance for a VXLAN in BD view.
         attribute :evpn
-        validates :evpn, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :evpn, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [Object, nil] Configures a route distinguisher (RD) for a BD EVPN instance. The format of an RD can be as follows,1) 2-byte AS number:4-byte user-defined number, for example, 1:3. An AS number is an integer ranging from 0 to 65535, and a user-defined number is an integer ranging from 0 to 4294967295. The AS and user-defined numbers cannot be both 0s. This means that an RD cannot be 0:0.,2) Integral 4-byte AS number:2-byte user-defined number, for example, 65537:3. An AS number is an integer ranging from 65536 to 4294967295, and a user-defined number is an integer ranging from 0 to 65535.,3) 4-byte AS number in dotted notation:2-byte user-defined number, for example, 0.0:3 or 0.1:0. A 4-byte AS number in dotted notation is in the format of x.y, where x and y are integers ranging from 0 to 65535.,4) A user-defined number is an integer ranging from 0 to 65535. The AS and user-defined numbers cannot be both 0s. This means that an RD cannot be 0.0:0.,5) 32-bit IP address:2-byte user-defined number. For example, 192.168.122.15:1. An IP address ranges from 0.0.0.0 to 255.255.255.255, and a user-defined number is an integer ranging from 0 to 65535.,6) 'auto' specifies the RD that is automatically generated.
         attribute :route_distinguisher
@@ -31,7 +31,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Manage the state of the resource.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_evpn_bgp.rb

@@ -23,22 +23,22 @@ module Ansible
 
         # @return [:true, :false, nil] Enable or disable a BGP device to exchange routes with a specified peer or peer group in the address family view.
         attribute :peer_enable
-        validates :peer_enable, inclusion: {:in=>[:true, :false], :message=>"%{value} needs to be :true, :false"}, allow_nil: true
+        validates :peer_enable, expression_inclusion: {:in=>[:true, :false], :message=>"%{value} needs to be :true, :false"}, allow_nil: true
 
         # @return [:arp, :irb, nil] Configures a device to advertise routes to its BGP EVPN peers.
         attribute :advertise_router_type
-        validates :advertise_router_type, inclusion: {:in=>[:arp, :irb], :message=>"%{value} needs to be :arp, :irb"}, allow_nil: true
+        validates :advertise_router_type, expression_inclusion: {:in=>[:arp, :irb], :message=>"%{value} needs to be :arp, :irb"}, allow_nil: true
 
         # @return [Object, nil] Associates a specified VPN instance with the IPv4 address family. The value is a string of 1 to 31 case-sensitive characters, spaces not supported.
         attribute :vpn_name
 
         # @return [:enable, :disable, nil] Enable or disable a device to advertise IP routes imported to a VPN instance to its EVPN instance.
         attribute :advertise_l2vpn_evpn
-        validates :advertise_l2vpn_evpn, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :advertise_l2vpn_evpn, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [:present, :absent, nil] Manage the state of the resource.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/network/cloudengine/ce_evpn_bgp_rr.rb

@@ -17,22 +17,22 @@ module Ansible
 
         # @return [:enable, :disable, nil] Enable or disable the BGP-EVPN address family.
         attribute :bgp_evpn_enable
-        validates :bgp_evpn_enable, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :bgp_evpn_enable, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [:group_name, :ipv4_address, nil] Specify the peer type.
         attribute :peer_type
-        validates :peer_type, inclusion: {:in=>[:group_name, :ipv4_address], :message=>"%{value} needs to be :group_name, :ipv4_address"}, allow_nil: true
+        validates :peer_type, expression_inclusion: {:in=>[:group_name, :ipv4_address], :message=>"%{value} needs to be :group_name, :ipv4_address"}, allow_nil: true
 
         # @return [Object, nil] Specifies the IPv4 address or the group name of a peer.
         attribute :peer
 
         # @return [:enable, :disable, nil] Configure the local device as the route reflector and the peer or peer group as the client of the route reflector.
         attribute :reflect_client
-        validates :reflect_client, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :reflect_client, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
 
         # @return [:enable, :disable, nil] Enable or disable the VPN-Target filtering.
         attribute :policy_vpn_target
-        validates :policy_vpn_target, inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
+        validates :policy_vpn_target, expression_inclusion: {:in=>[:enable, :disable], :message=>"%{value} needs to be :enable, :disable"}, allow_nil: true
       end
     end
   end