package Google::Cloud::Compute::V1::Compute::Types;

use strict;
use warnings;

use Type::Library -base;
use Type::Utils -all;
use Types::Standard -types;

declare 'AWSV4Signature',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AWSV4Signature'];

coerce 'AWSV4Signature',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AWSV4Signature'->new($_) };

declare 'RepeatedAWSV4Signature',
    as ArrayRef[AWSV4Signature()];

coerce 'RepeatedAWSV4Signature',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AWSV4Signature'->new($_) } @$_ ] };

declare 'MapStringAWSV4Signature',
    as HashRef[AWSV4Signature()];

declare 'AbandonInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AbandonInstancesInstanceGroupManagerRequest'];

coerce 'AbandonInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AbandonInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedAbandonInstancesInstanceGroupManagerRequest',
    as ArrayRef[AbandonInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedAbandonInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AbandonInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringAbandonInstancesInstanceGroupManagerRequest',
    as HashRef[AbandonInstancesInstanceGroupManagerRequest()];

declare 'AbandonInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AbandonInstancesRegionInstanceGroupManagerRequest'];

coerce 'AbandonInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AbandonInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedAbandonInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[AbandonInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedAbandonInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AbandonInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringAbandonInstancesRegionInstanceGroupManagerRequest',
    as HashRef[AbandonInstancesRegionInstanceGroupManagerRequest()];

declare 'AcceleratorConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorConfig'];

coerce 'AcceleratorConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorConfig'->new($_) };

declare 'RepeatedAcceleratorConfig',
    as ArrayRef[AcceleratorConfig()];

coerce 'RepeatedAcceleratorConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorConfig'->new($_) } @$_ ] };

declare 'MapStringAcceleratorConfig',
    as HashRef[AcceleratorConfig()];

declare 'AcceleratorTopologiesInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfo'];

coerce 'AcceleratorTopologiesInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfo'->new($_) };

declare 'RepeatedAcceleratorTopologiesInfo',
    as ArrayRef[AcceleratorTopologiesInfo()];

coerce 'RepeatedAcceleratorTopologiesInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfo'->new($_) } @$_ ] };

declare 'MapStringAcceleratorTopologiesInfo',
    as HashRef[AcceleratorTopologiesInfo()];

declare 'AcceleratorTopologiesInfoAcceleratorTopologyInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfoAcceleratorTopologyInfo'];

coerce 'AcceleratorTopologiesInfoAcceleratorTopologyInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfoAcceleratorTopologyInfo'->new($_) };

declare 'RepeatedAcceleratorTopologiesInfoAcceleratorTopologyInfo',
    as ArrayRef[AcceleratorTopologiesInfoAcceleratorTopologyInfo()];

coerce 'RepeatedAcceleratorTopologiesInfoAcceleratorTopologyInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfoAcceleratorTopologyInfo'->new($_) } @$_ ] };

declare 'MapStringAcceleratorTopologiesInfoAcceleratorTopologyInfo',
    as HashRef[AcceleratorTopologiesInfoAcceleratorTopologyInfo()];

declare 'AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState'];

coerce 'AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState'->new($_) };

declare 'RepeatedAcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState',
    as ArrayRef[AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState()];

coerce 'RepeatedAcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState'->new($_) } @$_ ] };

declare 'MapStringAcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState',
    as HashRef[AcceleratorTopologiesInfoAcceleratorTopologyInfoInfoPerTopologyState()];

declare 'State',
    as (Int | Str);

declare 'AcceleratorType',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorType'];

coerce 'AcceleratorType',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorType'->new($_) };

declare 'RepeatedAcceleratorType',
    as ArrayRef[AcceleratorType()];

coerce 'RepeatedAcceleratorType',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorType'->new($_) } @$_ ] };

declare 'MapStringAcceleratorType',
    as HashRef[AcceleratorType()];

declare 'AcceleratorTypeAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorTypeAggregatedList'];

coerce 'AcceleratorTypeAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypeAggregatedList'->new($_) };

declare 'RepeatedAcceleratorTypeAggregatedList',
    as ArrayRef[AcceleratorTypeAggregatedList()];

coerce 'RepeatedAcceleratorTypeAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypeAggregatedList'->new($_) } @$_ ] };

declare 'MapStringAcceleratorTypeAggregatedList',
    as HashRef[AcceleratorTypeAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorTypeAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypeAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypeAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'AcceleratorTypeList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorTypeList'];

coerce 'AcceleratorTypeList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypeList'->new($_) };

declare 'RepeatedAcceleratorTypeList',
    as ArrayRef[AcceleratorTypeList()];

coerce 'RepeatedAcceleratorTypeList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypeList'->new($_) } @$_ ] };

declare 'MapStringAcceleratorTypeList',
    as HashRef[AcceleratorTypeList()];

declare 'AcceleratorTypesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AcceleratorTypesScopedList'];

coerce 'AcceleratorTypesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypesScopedList'->new($_) };

declare 'RepeatedAcceleratorTypesScopedList',
    as ArrayRef[AcceleratorTypesScopedList()];

coerce 'RepeatedAcceleratorTypesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AcceleratorTypesScopedList'->new($_) } @$_ ] };

declare 'MapStringAcceleratorTypesScopedList',
    as HashRef[AcceleratorTypesScopedList()];

declare 'Accelerators',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Accelerators'];

coerce 'Accelerators',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Accelerators'->new($_) };

declare 'RepeatedAccelerators',
    as ArrayRef[Accelerators()];

coerce 'RepeatedAccelerators',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Accelerators'->new($_) } @$_ ] };

declare 'MapStringAccelerators',
    as HashRef[Accelerators()];

declare 'AccessConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AccessConfig'];

coerce 'AccessConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AccessConfig'->new($_) };

declare 'RepeatedAccessConfig',
    as ArrayRef[AccessConfig()];

coerce 'RepeatedAccessConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AccessConfig'->new($_) } @$_ ] };

declare 'MapStringAccessConfig',
    as HashRef[AccessConfig()];

declare 'NetworkTier',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'AddAccessConfigInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddAccessConfigInstanceRequest'];

coerce 'AddAccessConfigInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddAccessConfigInstanceRequest'->new($_) };

declare 'RepeatedAddAccessConfigInstanceRequest',
    as ArrayRef[AddAccessConfigInstanceRequest()];

coerce 'RepeatedAddAccessConfigInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddAccessConfigInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringAddAccessConfigInstanceRequest',
    as HashRef[AddAccessConfigInstanceRequest()];

declare 'AddAssociationFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddAssociationFirewallPolicyRequest'];

coerce 'AddAssociationFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddAssociationFirewallPolicyRequest'->new($_) };

declare 'RepeatedAddAssociationFirewallPolicyRequest',
    as ArrayRef[AddAssociationFirewallPolicyRequest()];

coerce 'RepeatedAddAssociationFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddAssociationFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddAssociationFirewallPolicyRequest',
    as HashRef[AddAssociationFirewallPolicyRequest()];

declare 'AddAssociationNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddAssociationNetworkFirewallPolicyRequest'];

coerce 'AddAssociationNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddAssociationNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedAddAssociationNetworkFirewallPolicyRequest',
    as ArrayRef[AddAssociationNetworkFirewallPolicyRequest()];

coerce 'RepeatedAddAssociationNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddAssociationNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddAssociationNetworkFirewallPolicyRequest',
    as HashRef[AddAssociationNetworkFirewallPolicyRequest()];

declare 'AddAssociationOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddAssociationOrganizationSecurityPolicyRequest'];

coerce 'AddAssociationOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddAssociationOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedAddAssociationOrganizationSecurityPolicyRequest',
    as ArrayRef[AddAssociationOrganizationSecurityPolicyRequest()];

coerce 'RepeatedAddAssociationOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddAssociationOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddAssociationOrganizationSecurityPolicyRequest',
    as HashRef[AddAssociationOrganizationSecurityPolicyRequest()];

declare 'AddAssociationRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddAssociationRegionNetworkFirewallPolicyRequest'];

coerce 'AddAssociationRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddAssociationRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedAddAssociationRegionNetworkFirewallPolicyRequest',
    as ArrayRef[AddAssociationRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedAddAssociationRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddAssociationRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddAssociationRegionNetworkFirewallPolicyRequest',
    as HashRef[AddAssociationRegionNetworkFirewallPolicyRequest()];

declare 'AddHealthCheckTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddHealthCheckTargetPoolRequest'];

coerce 'AddHealthCheckTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddHealthCheckTargetPoolRequest'->new($_) };

declare 'RepeatedAddHealthCheckTargetPoolRequest',
    as ArrayRef[AddHealthCheckTargetPoolRequest()];

coerce 'RepeatedAddHealthCheckTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddHealthCheckTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringAddHealthCheckTargetPoolRequest',
    as HashRef[AddHealthCheckTargetPoolRequest()];

declare 'AddInstanceTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddInstanceTargetPoolRequest'];

coerce 'AddInstanceTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddInstanceTargetPoolRequest'->new($_) };

declare 'RepeatedAddInstanceTargetPoolRequest',
    as ArrayRef[AddInstanceTargetPoolRequest()];

coerce 'RepeatedAddInstanceTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddInstanceTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringAddInstanceTargetPoolRequest',
    as HashRef[AddInstanceTargetPoolRequest()];

declare 'AddInstancesInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddInstancesInstanceGroupRequest'];

coerce 'AddInstancesInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddInstancesInstanceGroupRequest'->new($_) };

declare 'RepeatedAddInstancesInstanceGroupRequest',
    as ArrayRef[AddInstancesInstanceGroupRequest()];

coerce 'RepeatedAddInstancesInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddInstancesInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringAddInstancesInstanceGroupRequest',
    as HashRef[AddInstancesInstanceGroupRequest()];

declare 'AddNetworkInterfaceInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddNetworkInterfaceInstanceRequest'];

coerce 'AddNetworkInterfaceInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddNetworkInterfaceInstanceRequest'->new($_) };

declare 'RepeatedAddNetworkInterfaceInstanceRequest',
    as ArrayRef[AddNetworkInterfaceInstanceRequest()];

coerce 'RepeatedAddNetworkInterfaceInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddNetworkInterfaceInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringAddNetworkInterfaceInstanceRequest',
    as HashRef[AddNetworkInterfaceInstanceRequest()];

declare 'AddNodesNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddNodesNodeGroupRequest'];

coerce 'AddNodesNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddNodesNodeGroupRequest'->new($_) };

declare 'RepeatedAddNodesNodeGroupRequest',
    as ArrayRef[AddNodesNodeGroupRequest()];

coerce 'RepeatedAddNodesNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddNodesNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringAddNodesNodeGroupRequest',
    as HashRef[AddNodesNodeGroupRequest()];

declare 'AddPacketMirroringRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddPacketMirroringRuleNetworkFirewallPolicyRequest'];

coerce 'AddPacketMirroringRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddPacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedAddPacketMirroringRuleNetworkFirewallPolicyRequest',
    as ArrayRef[AddPacketMirroringRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedAddPacketMirroringRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddPacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddPacketMirroringRuleNetworkFirewallPolicyRequest',
    as HashRef[AddPacketMirroringRuleNetworkFirewallPolicyRequest()];

declare 'AddPeeringNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddPeeringNetworkRequest'];

coerce 'AddPeeringNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddPeeringNetworkRequest'->new($_) };

declare 'RepeatedAddPeeringNetworkRequest',
    as ArrayRef[AddPeeringNetworkRequest()];

coerce 'RepeatedAddPeeringNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddPeeringNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringAddPeeringNetworkRequest',
    as HashRef[AddPeeringNetworkRequest()];

declare 'AddResourcePoliciesDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddResourcePoliciesDiskRequest'];

coerce 'AddResourcePoliciesDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddResourcePoliciesDiskRequest'->new($_) };

declare 'RepeatedAddResourcePoliciesDiskRequest',
    as ArrayRef[AddResourcePoliciesDiskRequest()];

coerce 'RepeatedAddResourcePoliciesDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddResourcePoliciesDiskRequest'->new($_) } @$_ ] };

declare 'MapStringAddResourcePoliciesDiskRequest',
    as HashRef[AddResourcePoliciesDiskRequest()];

declare 'AddResourcePoliciesInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddResourcePoliciesInstanceRequest'];

coerce 'AddResourcePoliciesInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddResourcePoliciesInstanceRequest'->new($_) };

declare 'RepeatedAddResourcePoliciesInstanceRequest',
    as ArrayRef[AddResourcePoliciesInstanceRequest()];

coerce 'RepeatedAddResourcePoliciesInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddResourcePoliciesInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringAddResourcePoliciesInstanceRequest',
    as HashRef[AddResourcePoliciesInstanceRequest()];

declare 'AddResourcePoliciesRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddResourcePoliciesRegionDiskRequest'];

coerce 'AddResourcePoliciesRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddResourcePoliciesRegionDiskRequest'->new($_) };

declare 'RepeatedAddResourcePoliciesRegionDiskRequest',
    as ArrayRef[AddResourcePoliciesRegionDiskRequest()];

coerce 'RepeatedAddResourcePoliciesRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddResourcePoliciesRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringAddResourcePoliciesRegionDiskRequest',
    as HashRef[AddResourcePoliciesRegionDiskRequest()];

declare 'AddRuleFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddRuleFirewallPolicyRequest'];

coerce 'AddRuleFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddRuleFirewallPolicyRequest'->new($_) };

declare 'RepeatedAddRuleFirewallPolicyRequest',
    as ArrayRef[AddRuleFirewallPolicyRequest()];

coerce 'RepeatedAddRuleFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddRuleFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddRuleFirewallPolicyRequest',
    as HashRef[AddRuleFirewallPolicyRequest()];

declare 'AddRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddRuleNetworkFirewallPolicyRequest'];

coerce 'AddRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedAddRuleNetworkFirewallPolicyRequest',
    as ArrayRef[AddRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedAddRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddRuleNetworkFirewallPolicyRequest',
    as HashRef[AddRuleNetworkFirewallPolicyRequest()];

declare 'AddRuleOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddRuleOrganizationSecurityPolicyRequest'];

coerce 'AddRuleOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddRuleOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedAddRuleOrganizationSecurityPolicyRequest',
    as ArrayRef[AddRuleOrganizationSecurityPolicyRequest()];

coerce 'RepeatedAddRuleOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddRuleOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddRuleOrganizationSecurityPolicyRequest',
    as HashRef[AddRuleOrganizationSecurityPolicyRequest()];

declare 'AddRuleRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddRuleRegionNetworkFirewallPolicyRequest'];

coerce 'AddRuleRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddRuleRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedAddRuleRegionNetworkFirewallPolicyRequest',
    as ArrayRef[AddRuleRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedAddRuleRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddRuleRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddRuleRegionNetworkFirewallPolicyRequest',
    as HashRef[AddRuleRegionNetworkFirewallPolicyRequest()];

declare 'AddRuleRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddRuleRegionSecurityPolicyRequest'];

coerce 'AddRuleRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddRuleRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedAddRuleRegionSecurityPolicyRequest',
    as ArrayRef[AddRuleRegionSecurityPolicyRequest()];

coerce 'RepeatedAddRuleRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddRuleRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddRuleRegionSecurityPolicyRequest',
    as HashRef[AddRuleRegionSecurityPolicyRequest()];

declare 'AddRuleSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddRuleSecurityPolicyRequest'];

coerce 'AddRuleSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddRuleSecurityPolicyRequest'->new($_) };

declare 'RepeatedAddRuleSecurityPolicyRequest',
    as ArrayRef[AddRuleSecurityPolicyRequest()];

coerce 'RepeatedAddRuleSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddRuleSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringAddRuleSecurityPolicyRequest',
    as HashRef[AddRuleSecurityPolicyRequest()];

declare 'AddSignedUrlKeyBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddSignedUrlKeyBackendBucketRequest'];

coerce 'AddSignedUrlKeyBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddSignedUrlKeyBackendBucketRequest'->new($_) };

declare 'RepeatedAddSignedUrlKeyBackendBucketRequest',
    as ArrayRef[AddSignedUrlKeyBackendBucketRequest()];

coerce 'RepeatedAddSignedUrlKeyBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddSignedUrlKeyBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringAddSignedUrlKeyBackendBucketRequest',
    as HashRef[AddSignedUrlKeyBackendBucketRequest()];

declare 'AddSignedUrlKeyBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddSignedUrlKeyBackendServiceRequest'];

coerce 'AddSignedUrlKeyBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddSignedUrlKeyBackendServiceRequest'->new($_) };

declare 'RepeatedAddSignedUrlKeyBackendServiceRequest',
    as ArrayRef[AddSignedUrlKeyBackendServiceRequest()];

coerce 'RepeatedAddSignedUrlKeyBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddSignedUrlKeyBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringAddSignedUrlKeyBackendServiceRequest',
    as HashRef[AddSignedUrlKeyBackendServiceRequest()];

declare 'Address',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Address'];

coerce 'Address',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Address'->new($_) };

declare 'RepeatedAddress',
    as ArrayRef[Address()];

coerce 'RepeatedAddress',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Address'->new($_) } @$_ ] };

declare 'MapStringAddress',
    as HashRef[Address()];

declare 'AddressType',
    as (Int | Str);

declare 'IpVersion',
    as (Int | Str);

declare 'Ipv6EndpointType',
    as (Int | Str);

declare 'NetworkTier',
    as (Int | Str);

declare 'Purpose',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Address::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Address::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Address::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'AddressAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddressAggregatedList'];

coerce 'AddressAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddressAggregatedList'->new($_) };

declare 'RepeatedAddressAggregatedList',
    as ArrayRef[AddressAggregatedList()];

coerce 'RepeatedAddressAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddressAggregatedList'->new($_) } @$_ ] };

declare 'MapStringAddressAggregatedList',
    as HashRef[AddressAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddressAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddressAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddressAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'AddressList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddressList'];

coerce 'AddressList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddressList'->new($_) };

declare 'RepeatedAddressList',
    as ArrayRef[AddressList()];

coerce 'RepeatedAddressList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddressList'->new($_) } @$_ ] };

declare 'MapStringAddressList',
    as HashRef[AddressList()];

declare 'AddressesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AddressesScopedList'];

coerce 'AddressesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AddressesScopedList'->new($_) };

declare 'RepeatedAddressesScopedList',
    as ArrayRef[AddressesScopedList()];

coerce 'RepeatedAddressesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AddressesScopedList'->new($_) } @$_ ] };

declare 'MapStringAddressesScopedList',
    as HashRef[AddressesScopedList()];

declare 'AdvanceRolloutRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AdvanceRolloutRequest'];

coerce 'AdvanceRolloutRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AdvanceRolloutRequest'->new($_) };

declare 'RepeatedAdvanceRolloutRequest',
    as ArrayRef[AdvanceRolloutRequest()];

coerce 'RepeatedAdvanceRolloutRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AdvanceRolloutRequest'->new($_) } @$_ ] };

declare 'MapStringAdvanceRolloutRequest',
    as HashRef[AdvanceRolloutRequest()];

declare 'AdvancedMachineFeatures',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AdvancedMachineFeatures'];

coerce 'AdvancedMachineFeatures',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AdvancedMachineFeatures'->new($_) };

declare 'RepeatedAdvancedMachineFeatures',
    as ArrayRef[AdvancedMachineFeatures()];

coerce 'RepeatedAdvancedMachineFeatures',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AdvancedMachineFeatures'->new($_) } @$_ ] };

declare 'MapStringAdvancedMachineFeatures',
    as HashRef[AdvancedMachineFeatures()];

declare 'PerformanceMonitoringUnit',
    as (Int | Str);

declare 'AggregatedListAcceleratorTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListAcceleratorTypesRequest'];

coerce 'AggregatedListAcceleratorTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListAcceleratorTypesRequest'->new($_) };

declare 'RepeatedAggregatedListAcceleratorTypesRequest',
    as ArrayRef[AggregatedListAcceleratorTypesRequest()];

coerce 'RepeatedAggregatedListAcceleratorTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListAcceleratorTypesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListAcceleratorTypesRequest',
    as HashRef[AggregatedListAcceleratorTypesRequest()];

declare 'AggregatedListAddressesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListAddressesRequest'];

coerce 'AggregatedListAddressesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListAddressesRequest'->new($_) };

declare 'RepeatedAggregatedListAddressesRequest',
    as ArrayRef[AggregatedListAddressesRequest()];

coerce 'RepeatedAggregatedListAddressesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListAddressesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListAddressesRequest',
    as HashRef[AggregatedListAddressesRequest()];

declare 'AggregatedListAutoscalersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListAutoscalersRequest'];

coerce 'AggregatedListAutoscalersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListAutoscalersRequest'->new($_) };

declare 'RepeatedAggregatedListAutoscalersRequest',
    as ArrayRef[AggregatedListAutoscalersRequest()];

coerce 'RepeatedAggregatedListAutoscalersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListAutoscalersRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListAutoscalersRequest',
    as HashRef[AggregatedListAutoscalersRequest()];

declare 'AggregatedListBackendBucketsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListBackendBucketsRequest'];

coerce 'AggregatedListBackendBucketsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListBackendBucketsRequest'->new($_) };

declare 'RepeatedAggregatedListBackendBucketsRequest',
    as ArrayRef[AggregatedListBackendBucketsRequest()];

coerce 'RepeatedAggregatedListBackendBucketsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListBackendBucketsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListBackendBucketsRequest',
    as HashRef[AggregatedListBackendBucketsRequest()];

declare 'AggregatedListBackendServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListBackendServicesRequest'];

coerce 'AggregatedListBackendServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListBackendServicesRequest'->new($_) };

declare 'RepeatedAggregatedListBackendServicesRequest',
    as ArrayRef[AggregatedListBackendServicesRequest()];

coerce 'RepeatedAggregatedListBackendServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListBackendServicesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListBackendServicesRequest',
    as HashRef[AggregatedListBackendServicesRequest()];

declare 'AggregatedListDiskTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListDiskTypesRequest'];

coerce 'AggregatedListDiskTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListDiskTypesRequest'->new($_) };

declare 'RepeatedAggregatedListDiskTypesRequest',
    as ArrayRef[AggregatedListDiskTypesRequest()];

coerce 'RepeatedAggregatedListDiskTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListDiskTypesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListDiskTypesRequest',
    as HashRef[AggregatedListDiskTypesRequest()];

declare 'AggregatedListDisksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListDisksRequest'];

coerce 'AggregatedListDisksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListDisksRequest'->new($_) };

declare 'RepeatedAggregatedListDisksRequest',
    as ArrayRef[AggregatedListDisksRequest()];

coerce 'RepeatedAggregatedListDisksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListDisksRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListDisksRequest',
    as HashRef[AggregatedListDisksRequest()];

declare 'AggregatedListForwardingRulesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListForwardingRulesRequest'];

coerce 'AggregatedListForwardingRulesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListForwardingRulesRequest'->new($_) };

declare 'RepeatedAggregatedListForwardingRulesRequest',
    as ArrayRef[AggregatedListForwardingRulesRequest()];

coerce 'RepeatedAggregatedListForwardingRulesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListForwardingRulesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListForwardingRulesRequest',
    as HashRef[AggregatedListForwardingRulesRequest()];

declare 'AggregatedListFutureReservationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListFutureReservationsRequest'];

coerce 'AggregatedListFutureReservationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListFutureReservationsRequest'->new($_) };

declare 'RepeatedAggregatedListFutureReservationsRequest',
    as ArrayRef[AggregatedListFutureReservationsRequest()];

coerce 'RepeatedAggregatedListFutureReservationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListFutureReservationsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListFutureReservationsRequest',
    as HashRef[AggregatedListFutureReservationsRequest()];

declare 'AggregatedListGlobalOperationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListGlobalOperationsRequest'];

coerce 'AggregatedListGlobalOperationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListGlobalOperationsRequest'->new($_) };

declare 'RepeatedAggregatedListGlobalOperationsRequest',
    as ArrayRef[AggregatedListGlobalOperationsRequest()];

coerce 'RepeatedAggregatedListGlobalOperationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListGlobalOperationsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListGlobalOperationsRequest',
    as HashRef[AggregatedListGlobalOperationsRequest()];

declare 'AggregatedListGlobalVmExtensionPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListGlobalVmExtensionPoliciesRequest'];

coerce 'AggregatedListGlobalVmExtensionPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListGlobalVmExtensionPoliciesRequest'->new($_) };

declare 'RepeatedAggregatedListGlobalVmExtensionPoliciesRequest',
    as ArrayRef[AggregatedListGlobalVmExtensionPoliciesRequest()];

coerce 'RepeatedAggregatedListGlobalVmExtensionPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListGlobalVmExtensionPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListGlobalVmExtensionPoliciesRequest',
    as HashRef[AggregatedListGlobalVmExtensionPoliciesRequest()];

declare 'AggregatedListHealthChecksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListHealthChecksRequest'];

coerce 'AggregatedListHealthChecksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListHealthChecksRequest'->new($_) };

declare 'RepeatedAggregatedListHealthChecksRequest',
    as ArrayRef[AggregatedListHealthChecksRequest()];

coerce 'RepeatedAggregatedListHealthChecksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListHealthChecksRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListHealthChecksRequest',
    as HashRef[AggregatedListHealthChecksRequest()];

declare 'AggregatedListInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListInstanceGroupManagersRequest'];

coerce 'AggregatedListInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedAggregatedListInstanceGroupManagersRequest',
    as ArrayRef[AggregatedListInstanceGroupManagersRequest()];

coerce 'RepeatedAggregatedListInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListInstanceGroupManagersRequest',
    as HashRef[AggregatedListInstanceGroupManagersRequest()];

declare 'AggregatedListInstanceGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListInstanceGroupsRequest'];

coerce 'AggregatedListInstanceGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstanceGroupsRequest'->new($_) };

declare 'RepeatedAggregatedListInstanceGroupsRequest',
    as ArrayRef[AggregatedListInstanceGroupsRequest()];

coerce 'RepeatedAggregatedListInstanceGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstanceGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListInstanceGroupsRequest',
    as HashRef[AggregatedListInstanceGroupsRequest()];

declare 'AggregatedListInstanceTemplatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListInstanceTemplatesRequest'];

coerce 'AggregatedListInstanceTemplatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstanceTemplatesRequest'->new($_) };

declare 'RepeatedAggregatedListInstanceTemplatesRequest',
    as ArrayRef[AggregatedListInstanceTemplatesRequest()];

coerce 'RepeatedAggregatedListInstanceTemplatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstanceTemplatesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListInstanceTemplatesRequest',
    as HashRef[AggregatedListInstanceTemplatesRequest()];

declare 'AggregatedListInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListInstancesRequest'];

coerce 'AggregatedListInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstancesRequest'->new($_) };

declare 'RepeatedAggregatedListInstancesRequest',
    as ArrayRef[AggregatedListInstancesRequest()];

coerce 'RepeatedAggregatedListInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListInstancesRequest',
    as HashRef[AggregatedListInstancesRequest()];

declare 'AggregatedListInstantSnapshotsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListInstantSnapshotsRequest'];

coerce 'AggregatedListInstantSnapshotsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstantSnapshotsRequest'->new($_) };

declare 'RepeatedAggregatedListInstantSnapshotsRequest',
    as ArrayRef[AggregatedListInstantSnapshotsRequest()];

coerce 'RepeatedAggregatedListInstantSnapshotsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListInstantSnapshotsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListInstantSnapshotsRequest',
    as HashRef[AggregatedListInstantSnapshotsRequest()];

declare 'AggregatedListInterconnectAttachmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListInterconnectAttachmentsRequest'];

coerce 'AggregatedListInterconnectAttachmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListInterconnectAttachmentsRequest'->new($_) };

declare 'RepeatedAggregatedListInterconnectAttachmentsRequest',
    as ArrayRef[AggregatedListInterconnectAttachmentsRequest()];

coerce 'RepeatedAggregatedListInterconnectAttachmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListInterconnectAttachmentsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListInterconnectAttachmentsRequest',
    as HashRef[AggregatedListInterconnectAttachmentsRequest()];

declare 'AggregatedListMachineTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListMachineTypesRequest'];

coerce 'AggregatedListMachineTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListMachineTypesRequest'->new($_) };

declare 'RepeatedAggregatedListMachineTypesRequest',
    as ArrayRef[AggregatedListMachineTypesRequest()];

coerce 'RepeatedAggregatedListMachineTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListMachineTypesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListMachineTypesRequest',
    as HashRef[AggregatedListMachineTypesRequest()];

declare 'AggregatedListNetworkAttachmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListNetworkAttachmentsRequest'];

coerce 'AggregatedListNetworkAttachmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkAttachmentsRequest'->new($_) };

declare 'RepeatedAggregatedListNetworkAttachmentsRequest',
    as ArrayRef[AggregatedListNetworkAttachmentsRequest()];

coerce 'RepeatedAggregatedListNetworkAttachmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkAttachmentsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListNetworkAttachmentsRequest',
    as HashRef[AggregatedListNetworkAttachmentsRequest()];

declare 'AggregatedListNetworkEdgeSecurityServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListNetworkEdgeSecurityServicesRequest'];

coerce 'AggregatedListNetworkEdgeSecurityServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkEdgeSecurityServicesRequest'->new($_) };

declare 'RepeatedAggregatedListNetworkEdgeSecurityServicesRequest',
    as ArrayRef[AggregatedListNetworkEdgeSecurityServicesRequest()];

coerce 'RepeatedAggregatedListNetworkEdgeSecurityServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkEdgeSecurityServicesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListNetworkEdgeSecurityServicesRequest',
    as HashRef[AggregatedListNetworkEdgeSecurityServicesRequest()];

declare 'AggregatedListNetworkEndpointGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListNetworkEndpointGroupsRequest'];

coerce 'AggregatedListNetworkEndpointGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkEndpointGroupsRequest'->new($_) };

declare 'RepeatedAggregatedListNetworkEndpointGroupsRequest',
    as ArrayRef[AggregatedListNetworkEndpointGroupsRequest()];

coerce 'RepeatedAggregatedListNetworkEndpointGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkEndpointGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListNetworkEndpointGroupsRequest',
    as HashRef[AggregatedListNetworkEndpointGroupsRequest()];

declare 'AggregatedListNetworkFirewallPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListNetworkFirewallPoliciesRequest'];

coerce 'AggregatedListNetworkFirewallPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkFirewallPoliciesRequest'->new($_) };

declare 'RepeatedAggregatedListNetworkFirewallPoliciesRequest',
    as ArrayRef[AggregatedListNetworkFirewallPoliciesRequest()];

coerce 'RepeatedAggregatedListNetworkFirewallPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListNetworkFirewallPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListNetworkFirewallPoliciesRequest',
    as HashRef[AggregatedListNetworkFirewallPoliciesRequest()];

declare 'AggregatedListNodeGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListNodeGroupsRequest'];

coerce 'AggregatedListNodeGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListNodeGroupsRequest'->new($_) };

declare 'RepeatedAggregatedListNodeGroupsRequest',
    as ArrayRef[AggregatedListNodeGroupsRequest()];

coerce 'RepeatedAggregatedListNodeGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListNodeGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListNodeGroupsRequest',
    as HashRef[AggregatedListNodeGroupsRequest()];

declare 'AggregatedListNodeTemplatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListNodeTemplatesRequest'];

coerce 'AggregatedListNodeTemplatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListNodeTemplatesRequest'->new($_) };

declare 'RepeatedAggregatedListNodeTemplatesRequest',
    as ArrayRef[AggregatedListNodeTemplatesRequest()];

coerce 'RepeatedAggregatedListNodeTemplatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListNodeTemplatesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListNodeTemplatesRequest',
    as HashRef[AggregatedListNodeTemplatesRequest()];

declare 'AggregatedListNodeTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListNodeTypesRequest'];

coerce 'AggregatedListNodeTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListNodeTypesRequest'->new($_) };

declare 'RepeatedAggregatedListNodeTypesRequest',
    as ArrayRef[AggregatedListNodeTypesRequest()];

coerce 'RepeatedAggregatedListNodeTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListNodeTypesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListNodeTypesRequest',
    as HashRef[AggregatedListNodeTypesRequest()];

declare 'AggregatedListPacketMirroringsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListPacketMirroringsRequest'];

coerce 'AggregatedListPacketMirroringsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListPacketMirroringsRequest'->new($_) };

declare 'RepeatedAggregatedListPacketMirroringsRequest',
    as ArrayRef[AggregatedListPacketMirroringsRequest()];

coerce 'RepeatedAggregatedListPacketMirroringsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListPacketMirroringsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListPacketMirroringsRequest',
    as HashRef[AggregatedListPacketMirroringsRequest()];

declare 'AggregatedListPublicDelegatedPrefixesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListPublicDelegatedPrefixesRequest'];

coerce 'AggregatedListPublicDelegatedPrefixesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListPublicDelegatedPrefixesRequest'->new($_) };

declare 'RepeatedAggregatedListPublicDelegatedPrefixesRequest',
    as ArrayRef[AggregatedListPublicDelegatedPrefixesRequest()];

coerce 'RepeatedAggregatedListPublicDelegatedPrefixesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListPublicDelegatedPrefixesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListPublicDelegatedPrefixesRequest',
    as HashRef[AggregatedListPublicDelegatedPrefixesRequest()];

declare 'AggregatedListRegionCommitmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListRegionCommitmentsRequest'];

coerce 'AggregatedListRegionCommitmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionCommitmentsRequest'->new($_) };

declare 'RepeatedAggregatedListRegionCommitmentsRequest',
    as ArrayRef[AggregatedListRegionCommitmentsRequest()];

coerce 'RepeatedAggregatedListRegionCommitmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionCommitmentsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListRegionCommitmentsRequest',
    as HashRef[AggregatedListRegionCommitmentsRequest()];

declare 'AggregatedListRegionCompositeHealthChecksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListRegionCompositeHealthChecksRequest'];

coerce 'AggregatedListRegionCompositeHealthChecksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionCompositeHealthChecksRequest'->new($_) };

declare 'RepeatedAggregatedListRegionCompositeHealthChecksRequest',
    as ArrayRef[AggregatedListRegionCompositeHealthChecksRequest()];

coerce 'RepeatedAggregatedListRegionCompositeHealthChecksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionCompositeHealthChecksRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListRegionCompositeHealthChecksRequest',
    as HashRef[AggregatedListRegionCompositeHealthChecksRequest()];

declare 'AggregatedListRegionHealthAggregationPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthAggregationPoliciesRequest'];

coerce 'AggregatedListRegionHealthAggregationPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthAggregationPoliciesRequest'->new($_) };

declare 'RepeatedAggregatedListRegionHealthAggregationPoliciesRequest',
    as ArrayRef[AggregatedListRegionHealthAggregationPoliciesRequest()];

coerce 'RepeatedAggregatedListRegionHealthAggregationPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthAggregationPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListRegionHealthAggregationPoliciesRequest',
    as HashRef[AggregatedListRegionHealthAggregationPoliciesRequest()];

declare 'AggregatedListRegionHealthCheckServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthCheckServicesRequest'];

coerce 'AggregatedListRegionHealthCheckServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthCheckServicesRequest'->new($_) };

declare 'RepeatedAggregatedListRegionHealthCheckServicesRequest',
    as ArrayRef[AggregatedListRegionHealthCheckServicesRequest()];

coerce 'RepeatedAggregatedListRegionHealthCheckServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthCheckServicesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListRegionHealthCheckServicesRequest',
    as HashRef[AggregatedListRegionHealthCheckServicesRequest()];

declare 'AggregatedListRegionHealthSourcesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthSourcesRequest'];

coerce 'AggregatedListRegionHealthSourcesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthSourcesRequest'->new($_) };

declare 'RepeatedAggregatedListRegionHealthSourcesRequest',
    as ArrayRef[AggregatedListRegionHealthSourcesRequest()];

coerce 'RepeatedAggregatedListRegionHealthSourcesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionHealthSourcesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListRegionHealthSourcesRequest',
    as HashRef[AggregatedListRegionHealthSourcesRequest()];

declare 'AggregatedListRegionNotificationEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListRegionNotificationEndpointsRequest'];

coerce 'AggregatedListRegionNotificationEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionNotificationEndpointsRequest'->new($_) };

declare 'RepeatedAggregatedListRegionNotificationEndpointsRequest',
    as ArrayRef[AggregatedListRegionNotificationEndpointsRequest()];

coerce 'RepeatedAggregatedListRegionNotificationEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListRegionNotificationEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListRegionNotificationEndpointsRequest',
    as HashRef[AggregatedListRegionNotificationEndpointsRequest()];

declare 'AggregatedListReservationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListReservationsRequest'];

coerce 'AggregatedListReservationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListReservationsRequest'->new($_) };

declare 'RepeatedAggregatedListReservationsRequest',
    as ArrayRef[AggregatedListReservationsRequest()];

coerce 'RepeatedAggregatedListReservationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListReservationsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListReservationsRequest',
    as HashRef[AggregatedListReservationsRequest()];

declare 'AggregatedListResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListResourcePoliciesRequest'];

coerce 'AggregatedListResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListResourcePoliciesRequest'->new($_) };

declare 'RepeatedAggregatedListResourcePoliciesRequest',
    as ArrayRef[AggregatedListResourcePoliciesRequest()];

coerce 'RepeatedAggregatedListResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListResourcePoliciesRequest',
    as HashRef[AggregatedListResourcePoliciesRequest()];

declare 'AggregatedListRoutersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListRoutersRequest'];

coerce 'AggregatedListRoutersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListRoutersRequest'->new($_) };

declare 'RepeatedAggregatedListRoutersRequest',
    as ArrayRef[AggregatedListRoutersRequest()];

coerce 'RepeatedAggregatedListRoutersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListRoutersRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListRoutersRequest',
    as HashRef[AggregatedListRoutersRequest()];

declare 'AggregatedListSecurityPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListSecurityPoliciesRequest'];

coerce 'AggregatedListSecurityPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListSecurityPoliciesRequest'->new($_) };

declare 'RepeatedAggregatedListSecurityPoliciesRequest',
    as ArrayRef[AggregatedListSecurityPoliciesRequest()];

coerce 'RepeatedAggregatedListSecurityPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListSecurityPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListSecurityPoliciesRequest',
    as HashRef[AggregatedListSecurityPoliciesRequest()];

declare 'AggregatedListServiceAttachmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListServiceAttachmentsRequest'];

coerce 'AggregatedListServiceAttachmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListServiceAttachmentsRequest'->new($_) };

declare 'RepeatedAggregatedListServiceAttachmentsRequest',
    as ArrayRef[AggregatedListServiceAttachmentsRequest()];

coerce 'RepeatedAggregatedListServiceAttachmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListServiceAttachmentsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListServiceAttachmentsRequest',
    as HashRef[AggregatedListServiceAttachmentsRequest()];

declare 'AggregatedListSslCertificatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListSslCertificatesRequest'];

coerce 'AggregatedListSslCertificatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListSslCertificatesRequest'->new($_) };

declare 'RepeatedAggregatedListSslCertificatesRequest',
    as ArrayRef[AggregatedListSslCertificatesRequest()];

coerce 'RepeatedAggregatedListSslCertificatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListSslCertificatesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListSslCertificatesRequest',
    as HashRef[AggregatedListSslCertificatesRequest()];

declare 'AggregatedListSslPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListSslPoliciesRequest'];

coerce 'AggregatedListSslPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListSslPoliciesRequest'->new($_) };

declare 'RepeatedAggregatedListSslPoliciesRequest',
    as ArrayRef[AggregatedListSslPoliciesRequest()];

coerce 'RepeatedAggregatedListSslPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListSslPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListSslPoliciesRequest',
    as HashRef[AggregatedListSslPoliciesRequest()];

declare 'AggregatedListStoragePoolTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListStoragePoolTypesRequest'];

coerce 'AggregatedListStoragePoolTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListStoragePoolTypesRequest'->new($_) };

declare 'RepeatedAggregatedListStoragePoolTypesRequest',
    as ArrayRef[AggregatedListStoragePoolTypesRequest()];

coerce 'RepeatedAggregatedListStoragePoolTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListStoragePoolTypesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListStoragePoolTypesRequest',
    as HashRef[AggregatedListStoragePoolTypesRequest()];

declare 'AggregatedListStoragePoolsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListStoragePoolsRequest'];

coerce 'AggregatedListStoragePoolsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListStoragePoolsRequest'->new($_) };

declare 'RepeatedAggregatedListStoragePoolsRequest',
    as ArrayRef[AggregatedListStoragePoolsRequest()];

coerce 'RepeatedAggregatedListStoragePoolsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListStoragePoolsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListStoragePoolsRequest',
    as HashRef[AggregatedListStoragePoolsRequest()];

declare 'AggregatedListSubnetworksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListSubnetworksRequest'];

coerce 'AggregatedListSubnetworksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListSubnetworksRequest'->new($_) };

declare 'RepeatedAggregatedListSubnetworksRequest',
    as ArrayRef[AggregatedListSubnetworksRequest()];

coerce 'RepeatedAggregatedListSubnetworksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListSubnetworksRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListSubnetworksRequest',
    as HashRef[AggregatedListSubnetworksRequest()];

declare 'Views',
    as (Int | Str);

declare 'AggregatedListTargetHttpProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListTargetHttpProxiesRequest'];

coerce 'AggregatedListTargetHttpProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetHttpProxiesRequest'->new($_) };

declare 'RepeatedAggregatedListTargetHttpProxiesRequest',
    as ArrayRef[AggregatedListTargetHttpProxiesRequest()];

coerce 'RepeatedAggregatedListTargetHttpProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetHttpProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListTargetHttpProxiesRequest',
    as HashRef[AggregatedListTargetHttpProxiesRequest()];

declare 'AggregatedListTargetHttpsProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListTargetHttpsProxiesRequest'];

coerce 'AggregatedListTargetHttpsProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetHttpsProxiesRequest'->new($_) };

declare 'RepeatedAggregatedListTargetHttpsProxiesRequest',
    as ArrayRef[AggregatedListTargetHttpsProxiesRequest()];

coerce 'RepeatedAggregatedListTargetHttpsProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetHttpsProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListTargetHttpsProxiesRequest',
    as HashRef[AggregatedListTargetHttpsProxiesRequest()];

declare 'AggregatedListTargetInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListTargetInstancesRequest'];

coerce 'AggregatedListTargetInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetInstancesRequest'->new($_) };

declare 'RepeatedAggregatedListTargetInstancesRequest',
    as ArrayRef[AggregatedListTargetInstancesRequest()];

coerce 'RepeatedAggregatedListTargetInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListTargetInstancesRequest',
    as HashRef[AggregatedListTargetInstancesRequest()];

declare 'AggregatedListTargetPoolsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListTargetPoolsRequest'];

coerce 'AggregatedListTargetPoolsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetPoolsRequest'->new($_) };

declare 'RepeatedAggregatedListTargetPoolsRequest',
    as ArrayRef[AggregatedListTargetPoolsRequest()];

coerce 'RepeatedAggregatedListTargetPoolsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetPoolsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListTargetPoolsRequest',
    as HashRef[AggregatedListTargetPoolsRequest()];

declare 'AggregatedListTargetTcpProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListTargetTcpProxiesRequest'];

coerce 'AggregatedListTargetTcpProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetTcpProxiesRequest'->new($_) };

declare 'RepeatedAggregatedListTargetTcpProxiesRequest',
    as ArrayRef[AggregatedListTargetTcpProxiesRequest()];

coerce 'RepeatedAggregatedListTargetTcpProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetTcpProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListTargetTcpProxiesRequest',
    as HashRef[AggregatedListTargetTcpProxiesRequest()];

declare 'AggregatedListTargetVpnGatewaysRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListTargetVpnGatewaysRequest'];

coerce 'AggregatedListTargetVpnGatewaysRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetVpnGatewaysRequest'->new($_) };

declare 'RepeatedAggregatedListTargetVpnGatewaysRequest',
    as ArrayRef[AggregatedListTargetVpnGatewaysRequest()];

coerce 'RepeatedAggregatedListTargetVpnGatewaysRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListTargetVpnGatewaysRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListTargetVpnGatewaysRequest',
    as HashRef[AggregatedListTargetVpnGatewaysRequest()];

declare 'AggregatedListUrlMapsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListUrlMapsRequest'];

coerce 'AggregatedListUrlMapsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListUrlMapsRequest'->new($_) };

declare 'RepeatedAggregatedListUrlMapsRequest',
    as ArrayRef[AggregatedListUrlMapsRequest()];

coerce 'RepeatedAggregatedListUrlMapsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListUrlMapsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListUrlMapsRequest',
    as HashRef[AggregatedListUrlMapsRequest()];

declare 'AggregatedListVpnGatewaysRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListVpnGatewaysRequest'];

coerce 'AggregatedListVpnGatewaysRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListVpnGatewaysRequest'->new($_) };

declare 'RepeatedAggregatedListVpnGatewaysRequest',
    as ArrayRef[AggregatedListVpnGatewaysRequest()];

coerce 'RepeatedAggregatedListVpnGatewaysRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListVpnGatewaysRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListVpnGatewaysRequest',
    as HashRef[AggregatedListVpnGatewaysRequest()];

declare 'AggregatedListVpnTunnelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AggregatedListVpnTunnelsRequest'];

coerce 'AggregatedListVpnTunnelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AggregatedListVpnTunnelsRequest'->new($_) };

declare 'RepeatedAggregatedListVpnTunnelsRequest',
    as ArrayRef[AggregatedListVpnTunnelsRequest()];

coerce 'RepeatedAggregatedListVpnTunnelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AggregatedListVpnTunnelsRequest'->new($_) } @$_ ] };

declare 'MapStringAggregatedListVpnTunnelsRequest',
    as HashRef[AggregatedListVpnTunnelsRequest()];

declare 'AliasIpRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AliasIpRange'];

coerce 'AliasIpRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AliasIpRange'->new($_) };

declare 'RepeatedAliasIpRange',
    as ArrayRef[AliasIpRange()];

coerce 'RepeatedAliasIpRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AliasIpRange'->new($_) } @$_ ] };

declare 'MapStringAliasIpRange',
    as HashRef[AliasIpRange()];

declare 'AllocationAggregateReservation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationAggregateReservation'];

coerce 'AllocationAggregateReservation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationAggregateReservation'->new($_) };

declare 'RepeatedAllocationAggregateReservation',
    as ArrayRef[AllocationAggregateReservation()];

coerce 'RepeatedAllocationAggregateReservation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationAggregateReservation'->new($_) } @$_ ] };

declare 'MapStringAllocationAggregateReservation',
    as HashRef[AllocationAggregateReservation()];

declare 'VmFamily',
    as (Int | Str);

declare 'WorkloadType',
    as (Int | Str);

declare 'AllocationAggregateReservationReservedResourceInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationAggregateReservationReservedResourceInfo'];

coerce 'AllocationAggregateReservationReservedResourceInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationAggregateReservationReservedResourceInfo'->new($_) };

declare 'RepeatedAllocationAggregateReservationReservedResourceInfo',
    as ArrayRef[AllocationAggregateReservationReservedResourceInfo()];

coerce 'RepeatedAllocationAggregateReservationReservedResourceInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationAggregateReservationReservedResourceInfo'->new($_) } @$_ ] };

declare 'MapStringAllocationAggregateReservationReservedResourceInfo',
    as HashRef[AllocationAggregateReservationReservedResourceInfo()];

declare 'AllocationAggregateReservationReservedResourceInfoAccelerator',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationAggregateReservationReservedResourceInfoAccelerator'];

coerce 'AllocationAggregateReservationReservedResourceInfoAccelerator',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationAggregateReservationReservedResourceInfoAccelerator'->new($_) };

declare 'RepeatedAllocationAggregateReservationReservedResourceInfoAccelerator',
    as ArrayRef[AllocationAggregateReservationReservedResourceInfoAccelerator()];

coerce 'RepeatedAllocationAggregateReservationReservedResourceInfoAccelerator',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationAggregateReservationReservedResourceInfoAccelerator'->new($_) } @$_ ] };

declare 'MapStringAllocationAggregateReservationReservedResourceInfoAccelerator',
    as HashRef[AllocationAggregateReservationReservedResourceInfoAccelerator()];

declare 'AllocationReservationSharingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationReservationSharingPolicy'];

coerce 'AllocationReservationSharingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationReservationSharingPolicy'->new($_) };

declare 'RepeatedAllocationReservationSharingPolicy',
    as ArrayRef[AllocationReservationSharingPolicy()];

coerce 'RepeatedAllocationReservationSharingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationReservationSharingPolicy'->new($_) } @$_ ] };

declare 'MapStringAllocationReservationSharingPolicy',
    as HashRef[AllocationReservationSharingPolicy()];

declare 'ServiceShareType',
    as (Int | Str);

declare 'AllocationResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationResourceStatus'];

coerce 'AllocationResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatus'->new($_) };

declare 'RepeatedAllocationResourceStatus',
    as ArrayRef[AllocationResourceStatus()];

coerce 'RepeatedAllocationResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatus'->new($_) } @$_ ] };

declare 'MapStringAllocationResourceStatus',
    as HashRef[AllocationResourceStatus()];

declare 'AllocationResourceStatusHealthInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationResourceStatusHealthInfo'];

coerce 'AllocationResourceStatusHealthInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatusHealthInfo'->new($_) };

declare 'RepeatedAllocationResourceStatusHealthInfo',
    as ArrayRef[AllocationResourceStatusHealthInfo()];

coerce 'RepeatedAllocationResourceStatusHealthInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatusHealthInfo'->new($_) } @$_ ] };

declare 'MapStringAllocationResourceStatusHealthInfo',
    as HashRef[AllocationResourceStatusHealthInfo()];

declare 'HealthStatus',
    as (Int | Str);

declare 'AllocationResourceStatusSpecificSKUAllocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationResourceStatusSpecificSKUAllocation'];

coerce 'AllocationResourceStatusSpecificSKUAllocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatusSpecificSKUAllocation'->new($_) };

declare 'RepeatedAllocationResourceStatusSpecificSKUAllocation',
    as ArrayRef[AllocationResourceStatusSpecificSKUAllocation()];

coerce 'RepeatedAllocationResourceStatusSpecificSKUAllocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatusSpecificSKUAllocation'->new($_) } @$_ ] };

declare 'MapStringAllocationResourceStatusSpecificSKUAllocation',
    as HashRef[AllocationResourceStatusSpecificSKUAllocation()];

declare 'UtilizationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationResourceStatusSpecificSKUAllocation::UtilizationsEntry'];

coerce 'UtilizationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatusSpecificSKUAllocation::UtilizationsEntry'->new($_) };

declare 'RepeatedUtilizationsEntry',
    as ArrayRef[UtilizationsEntry()];

coerce 'RepeatedUtilizationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationResourceStatusSpecificSKUAllocation::UtilizationsEntry'->new($_) } @$_ ] };

declare 'MapStringUtilizationsEntry',
    as HashRef[UtilizationsEntry()];

declare 'AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk'];

coerce 'AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk'->new($_) };

declare 'RepeatedAllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk',
    as ArrayRef[AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk()];

coerce 'RepeatedAllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk'->new($_) } @$_ ] };

declare 'MapStringAllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk',
    as HashRef[AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk()];

declare 'Interface',
    as (Int | Str);

declare 'AllocationSpecificSKUAllocationReservedInstanceProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUAllocationReservedInstanceProperties'];

coerce 'AllocationSpecificSKUAllocationReservedInstanceProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUAllocationReservedInstanceProperties'->new($_) };

declare 'RepeatedAllocationSpecificSKUAllocationReservedInstanceProperties',
    as ArrayRef[AllocationSpecificSKUAllocationReservedInstanceProperties()];

coerce 'RepeatedAllocationSpecificSKUAllocationReservedInstanceProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUAllocationReservedInstanceProperties'->new($_) } @$_ ] };

declare 'MapStringAllocationSpecificSKUAllocationReservedInstanceProperties',
    as HashRef[AllocationSpecificSKUAllocationReservedInstanceProperties()];

declare 'AllocationSpecificSKUReservation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUReservation'];

coerce 'AllocationSpecificSKUReservation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUReservation'->new($_) };

declare 'RepeatedAllocationSpecificSKUReservation',
    as ArrayRef[AllocationSpecificSKUReservation()];

coerce 'RepeatedAllocationSpecificSKUReservation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AllocationSpecificSKUReservation'->new($_) } @$_ ] };

declare 'MapStringAllocationSpecificSKUReservation',
    as HashRef[AllocationSpecificSKUReservation()];

declare 'Allowed',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Allowed'];

coerce 'Allowed',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Allowed'->new($_) };

declare 'RepeatedAllowed',
    as ArrayRef[Allowed()];

coerce 'RepeatedAllowed',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Allowed'->new($_) } @$_ ] };

declare 'MapStringAllowed',
    as HashRef[Allowed()];

declare 'AnnouncePublicAdvertisedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AnnouncePublicAdvertisedPrefixeRequest'];

coerce 'AnnouncePublicAdvertisedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AnnouncePublicAdvertisedPrefixeRequest'->new($_) };

declare 'RepeatedAnnouncePublicAdvertisedPrefixeRequest',
    as ArrayRef[AnnouncePublicAdvertisedPrefixeRequest()];

coerce 'RepeatedAnnouncePublicAdvertisedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AnnouncePublicAdvertisedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringAnnouncePublicAdvertisedPrefixeRequest',
    as HashRef[AnnouncePublicAdvertisedPrefixeRequest()];

declare 'AnnouncePublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AnnouncePublicDelegatedPrefixeRequest'];

coerce 'AnnouncePublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AnnouncePublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedAnnouncePublicDelegatedPrefixeRequest',
    as ArrayRef[AnnouncePublicDelegatedPrefixeRequest()];

coerce 'RepeatedAnnouncePublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AnnouncePublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringAnnouncePublicDelegatedPrefixeRequest',
    as HashRef[AnnouncePublicDelegatedPrefixeRequest()];

declare 'ApplyUpdatesToInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ApplyUpdatesToInstancesInstanceGroupManagerRequest'];

coerce 'ApplyUpdatesToInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ApplyUpdatesToInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedApplyUpdatesToInstancesInstanceGroupManagerRequest',
    as ArrayRef[ApplyUpdatesToInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedApplyUpdatesToInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ApplyUpdatesToInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringApplyUpdatesToInstancesInstanceGroupManagerRequest',
    as HashRef[ApplyUpdatesToInstancesInstanceGroupManagerRequest()];

declare 'ApplyUpdatesToInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ApplyUpdatesToInstancesRegionInstanceGroupManagerRequest'];

coerce 'ApplyUpdatesToInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ApplyUpdatesToInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedApplyUpdatesToInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[ApplyUpdatesToInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedApplyUpdatesToInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ApplyUpdatesToInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringApplyUpdatesToInstancesRegionInstanceGroupManagerRequest',
    as HashRef[ApplyUpdatesToInstancesRegionInstanceGroupManagerRequest()];

declare 'AttachDiskInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachDiskInstanceRequest'];

coerce 'AttachDiskInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachDiskInstanceRequest'->new($_) };

declare 'RepeatedAttachDiskInstanceRequest',
    as ArrayRef[AttachDiskInstanceRequest()];

coerce 'RepeatedAttachDiskInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachDiskInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringAttachDiskInstanceRequest',
    as HashRef[AttachDiskInstanceRequest()];

declare 'AttachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsGlobalNetworkEndpointGroupRequest'];

coerce 'AttachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsGlobalNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedAttachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    as ArrayRef[AttachNetworkEndpointsGlobalNetworkEndpointGroupRequest()];

coerce 'RepeatedAttachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsGlobalNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringAttachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    as HashRef[AttachNetworkEndpointsGlobalNetworkEndpointGroupRequest()];

declare 'AttachNetworkEndpointsNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsNetworkEndpointGroupRequest'];

coerce 'AttachNetworkEndpointsNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedAttachNetworkEndpointsNetworkEndpointGroupRequest',
    as ArrayRef[AttachNetworkEndpointsNetworkEndpointGroupRequest()];

coerce 'RepeatedAttachNetworkEndpointsNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringAttachNetworkEndpointsNetworkEndpointGroupRequest',
    as HashRef[AttachNetworkEndpointsNetworkEndpointGroupRequest()];

declare 'AttachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsRegionNetworkEndpointGroupRequest'];

coerce 'AttachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsRegionNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedAttachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    as ArrayRef[AttachNetworkEndpointsRegionNetworkEndpointGroupRequest()];

coerce 'RepeatedAttachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachNetworkEndpointsRegionNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringAttachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    as HashRef[AttachNetworkEndpointsRegionNetworkEndpointGroupRequest()];

declare 'AttachedDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachedDisk'];

coerce 'AttachedDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachedDisk'->new($_) };

declare 'RepeatedAttachedDisk',
    as ArrayRef[AttachedDisk()];

coerce 'RepeatedAttachedDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachedDisk'->new($_) } @$_ ] };

declare 'MapStringAttachedDisk',
    as HashRef[AttachedDisk()];

declare 'Architecture',
    as (Int | Str);

declare 'Interface',
    as (Int | Str);

declare 'Mode',
    as (Int | Str);

declare 'SavedState',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'AttachedDiskInitializeParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams'];

coerce 'AttachedDiskInitializeParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams'->new($_) };

declare 'RepeatedAttachedDiskInitializeParams',
    as ArrayRef[AttachedDiskInitializeParams()];

coerce 'RepeatedAttachedDiskInitializeParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams'->new($_) } @$_ ] };

declare 'MapStringAttachedDiskInitializeParams',
    as HashRef[AttachedDiskInitializeParams()];

declare 'Architecture',
    as (Int | Str);

declare 'OnUpdateAction',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AttachedDiskInitializeParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'AuditConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AuditConfig'];

coerce 'AuditConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AuditConfig'->new($_) };

declare 'RepeatedAuditConfig',
    as ArrayRef[AuditConfig()];

coerce 'RepeatedAuditConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AuditConfig'->new($_) } @$_ ] };

declare 'MapStringAuditConfig',
    as HashRef[AuditConfig()];

declare 'AuditLogConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AuditLogConfig'];

coerce 'AuditLogConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AuditLogConfig'->new($_) };

declare 'RepeatedAuditLogConfig',
    as ArrayRef[AuditLogConfig()];

coerce 'RepeatedAuditLogConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AuditLogConfig'->new($_) } @$_ ] };

declare 'MapStringAuditLogConfig',
    as HashRef[AuditLogConfig()];

declare 'LogType',
    as (Int | Str);

declare 'Autoscaler',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Autoscaler'];

coerce 'Autoscaler',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Autoscaler'->new($_) };

declare 'RepeatedAutoscaler',
    as ArrayRef[Autoscaler()];

coerce 'RepeatedAutoscaler',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Autoscaler'->new($_) } @$_ ] };

declare 'MapStringAutoscaler',
    as HashRef[Autoscaler()];

declare 'Status',
    as (Int | Str);

declare 'ScalingScheduleStatusEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Autoscaler::ScalingScheduleStatusEntry'];

coerce 'ScalingScheduleStatusEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Autoscaler::ScalingScheduleStatusEntry'->new($_) };

declare 'RepeatedScalingScheduleStatusEntry',
    as ArrayRef[ScalingScheduleStatusEntry()];

coerce 'RepeatedScalingScheduleStatusEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Autoscaler::ScalingScheduleStatusEntry'->new($_) } @$_ ] };

declare 'MapStringScalingScheduleStatusEntry',
    as HashRef[ScalingScheduleStatusEntry()];

declare 'AutoscalerAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalerAggregatedList'];

coerce 'AutoscalerAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalerAggregatedList'->new($_) };

declare 'RepeatedAutoscalerAggregatedList',
    as ArrayRef[AutoscalerAggregatedList()];

coerce 'RepeatedAutoscalerAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalerAggregatedList'->new($_) } @$_ ] };

declare 'MapStringAutoscalerAggregatedList',
    as HashRef[AutoscalerAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalerAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalerAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalerAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'AutoscalerList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalerList'];

coerce 'AutoscalerList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalerList'->new($_) };

declare 'RepeatedAutoscalerList',
    as ArrayRef[AutoscalerList()];

coerce 'RepeatedAutoscalerList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalerList'->new($_) } @$_ ] };

declare 'MapStringAutoscalerList',
    as HashRef[AutoscalerList()];

declare 'AutoscalerStatusDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalerStatusDetails'];

coerce 'AutoscalerStatusDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalerStatusDetails'->new($_) };

declare 'RepeatedAutoscalerStatusDetails',
    as ArrayRef[AutoscalerStatusDetails()];

coerce 'RepeatedAutoscalerStatusDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalerStatusDetails'->new($_) } @$_ ] };

declare 'MapStringAutoscalerStatusDetails',
    as HashRef[AutoscalerStatusDetails()];

declare 'Type',
    as (Int | Str);

declare 'AutoscalersScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalersScopedList'];

coerce 'AutoscalersScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalersScopedList'->new($_) };

declare 'RepeatedAutoscalersScopedList',
    as ArrayRef[AutoscalersScopedList()];

coerce 'RepeatedAutoscalersScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalersScopedList'->new($_) } @$_ ] };

declare 'MapStringAutoscalersScopedList',
    as HashRef[AutoscalersScopedList()];

declare 'AutoscalingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalingPolicy'];

coerce 'AutoscalingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicy'->new($_) };

declare 'RepeatedAutoscalingPolicy',
    as ArrayRef[AutoscalingPolicy()];

coerce 'RepeatedAutoscalingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicy'->new($_) } @$_ ] };

declare 'MapStringAutoscalingPolicy',
    as HashRef[AutoscalingPolicy()];

declare 'Mode',
    as (Int | Str);

declare 'ScalingSchedulesEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalingPolicy::ScalingSchedulesEntry'];

coerce 'ScalingSchedulesEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicy::ScalingSchedulesEntry'->new($_) };

declare 'RepeatedScalingSchedulesEntry',
    as ArrayRef[ScalingSchedulesEntry()];

coerce 'RepeatedScalingSchedulesEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicy::ScalingSchedulesEntry'->new($_) } @$_ ] };

declare 'MapStringScalingSchedulesEntry',
    as HashRef[ScalingSchedulesEntry()];

declare 'AutoscalingPolicyCpuUtilization',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalingPolicyCpuUtilization'];

coerce 'AutoscalingPolicyCpuUtilization',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyCpuUtilization'->new($_) };

declare 'RepeatedAutoscalingPolicyCpuUtilization',
    as ArrayRef[AutoscalingPolicyCpuUtilization()];

coerce 'RepeatedAutoscalingPolicyCpuUtilization',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyCpuUtilization'->new($_) } @$_ ] };

declare 'MapStringAutoscalingPolicyCpuUtilization',
    as HashRef[AutoscalingPolicyCpuUtilization()];

declare 'PredictiveMethod',
    as (Int | Str);

declare 'AutoscalingPolicyCustomMetricUtilization',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalingPolicyCustomMetricUtilization'];

coerce 'AutoscalingPolicyCustomMetricUtilization',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyCustomMetricUtilization'->new($_) };

declare 'RepeatedAutoscalingPolicyCustomMetricUtilization',
    as ArrayRef[AutoscalingPolicyCustomMetricUtilization()];

coerce 'RepeatedAutoscalingPolicyCustomMetricUtilization',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyCustomMetricUtilization'->new($_) } @$_ ] };

declare 'MapStringAutoscalingPolicyCustomMetricUtilization',
    as HashRef[AutoscalingPolicyCustomMetricUtilization()];

declare 'UtilizationTargetType',
    as (Int | Str);

declare 'AutoscalingPolicyLoadBalancingUtilization',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalingPolicyLoadBalancingUtilization'];

coerce 'AutoscalingPolicyLoadBalancingUtilization',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyLoadBalancingUtilization'->new($_) };

declare 'RepeatedAutoscalingPolicyLoadBalancingUtilization',
    as ArrayRef[AutoscalingPolicyLoadBalancingUtilization()];

coerce 'RepeatedAutoscalingPolicyLoadBalancingUtilization',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyLoadBalancingUtilization'->new($_) } @$_ ] };

declare 'MapStringAutoscalingPolicyLoadBalancingUtilization',
    as HashRef[AutoscalingPolicyLoadBalancingUtilization()];

declare 'AutoscalingPolicyScaleInControl',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalingPolicyScaleInControl'];

coerce 'AutoscalingPolicyScaleInControl',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyScaleInControl'->new($_) };

declare 'RepeatedAutoscalingPolicyScaleInControl',
    as ArrayRef[AutoscalingPolicyScaleInControl()];

coerce 'RepeatedAutoscalingPolicyScaleInControl',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyScaleInControl'->new($_) } @$_ ] };

declare 'MapStringAutoscalingPolicyScaleInControl',
    as HashRef[AutoscalingPolicyScaleInControl()];

declare 'AutoscalingPolicyScalingSchedule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::AutoscalingPolicyScalingSchedule'];

coerce 'AutoscalingPolicyScalingSchedule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyScalingSchedule'->new($_) };

declare 'RepeatedAutoscalingPolicyScalingSchedule',
    as ArrayRef[AutoscalingPolicyScalingSchedule()];

coerce 'RepeatedAutoscalingPolicyScalingSchedule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::AutoscalingPolicyScalingSchedule'->new($_) } @$_ ] };

declare 'MapStringAutoscalingPolicyScalingSchedule',
    as HashRef[AutoscalingPolicyScalingSchedule()];

declare 'Backend',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Backend'];

coerce 'Backend',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Backend'->new($_) };

declare 'RepeatedBackend',
    as ArrayRef[Backend()];

coerce 'RepeatedBackend',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Backend'->new($_) } @$_ ] };

declare 'MapStringBackend',
    as HashRef[Backend()];

declare 'BalancingMode',
    as (Int | Str);

declare 'Preference',
    as (Int | Str);

declare 'TrafficDuration',
    as (Int | Str);

declare 'BackendBackendOrchestrationInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBackendOrchestrationInfo'];

coerce 'BackendBackendOrchestrationInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBackendOrchestrationInfo'->new($_) };

declare 'RepeatedBackendBackendOrchestrationInfo',
    as ArrayRef[BackendBackendOrchestrationInfo()];

coerce 'RepeatedBackendBackendOrchestrationInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBackendOrchestrationInfo'->new($_) } @$_ ] };

declare 'MapStringBackendBackendOrchestrationInfo',
    as HashRef[BackendBackendOrchestrationInfo()];

declare 'BackendBucket',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucket'];

coerce 'BackendBucket',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucket'->new($_) };

declare 'RepeatedBackendBucket',
    as ArrayRef[BackendBucket()];

coerce 'RepeatedBackendBucket',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucket'->new($_) } @$_ ] };

declare 'MapStringBackendBucket',
    as HashRef[BackendBucket()];

declare 'CompressionMode',
    as (Int | Str);

declare 'LoadBalancingScheme',
    as (Int | Str);

declare 'BackendBucketAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketAggregatedList'];

coerce 'BackendBucketAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketAggregatedList'->new($_) };

declare 'RepeatedBackendBucketAggregatedList',
    as ArrayRef[BackendBucketAggregatedList()];

coerce 'RepeatedBackendBucketAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketAggregatedList'->new($_) } @$_ ] };

declare 'MapStringBackendBucketAggregatedList',
    as HashRef[BackendBucketAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'BackendBucketCdnPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicy'];

coerce 'BackendBucketCdnPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicy'->new($_) };

declare 'RepeatedBackendBucketCdnPolicy',
    as ArrayRef[BackendBucketCdnPolicy()];

coerce 'RepeatedBackendBucketCdnPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendBucketCdnPolicy',
    as HashRef[BackendBucketCdnPolicy()];

declare 'CacheMode',
    as (Int | Str);

declare 'BackendBucketCdnPolicyBypassCacheOnRequestHeader',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyBypassCacheOnRequestHeader'];

coerce 'BackendBucketCdnPolicyBypassCacheOnRequestHeader',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyBypassCacheOnRequestHeader'->new($_) };

declare 'RepeatedBackendBucketCdnPolicyBypassCacheOnRequestHeader',
    as ArrayRef[BackendBucketCdnPolicyBypassCacheOnRequestHeader()];

coerce 'RepeatedBackendBucketCdnPolicyBypassCacheOnRequestHeader',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyBypassCacheOnRequestHeader'->new($_) } @$_ ] };

declare 'MapStringBackendBucketCdnPolicyBypassCacheOnRequestHeader',
    as HashRef[BackendBucketCdnPolicyBypassCacheOnRequestHeader()];

declare 'BackendBucketCdnPolicyCacheKeyPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyCacheKeyPolicy'];

coerce 'BackendBucketCdnPolicyCacheKeyPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyCacheKeyPolicy'->new($_) };

declare 'RepeatedBackendBucketCdnPolicyCacheKeyPolicy',
    as ArrayRef[BackendBucketCdnPolicyCacheKeyPolicy()];

coerce 'RepeatedBackendBucketCdnPolicyCacheKeyPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyCacheKeyPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendBucketCdnPolicyCacheKeyPolicy',
    as HashRef[BackendBucketCdnPolicyCacheKeyPolicy()];

declare 'BackendBucketCdnPolicyNegativeCachingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyNegativeCachingPolicy'];

coerce 'BackendBucketCdnPolicyNegativeCachingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyNegativeCachingPolicy'->new($_) };

declare 'RepeatedBackendBucketCdnPolicyNegativeCachingPolicy',
    as ArrayRef[BackendBucketCdnPolicyNegativeCachingPolicy()];

coerce 'RepeatedBackendBucketCdnPolicyNegativeCachingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketCdnPolicyNegativeCachingPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendBucketCdnPolicyNegativeCachingPolicy',
    as HashRef[BackendBucketCdnPolicyNegativeCachingPolicy()];

declare 'BackendBucketList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketList'];

coerce 'BackendBucketList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketList'->new($_) };

declare 'RepeatedBackendBucketList',
    as ArrayRef[BackendBucketList()];

coerce 'RepeatedBackendBucketList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketList'->new($_) } @$_ ] };

declare 'MapStringBackendBucketList',
    as HashRef[BackendBucketList()];

declare 'BackendBucketListUsable',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketListUsable'];

coerce 'BackendBucketListUsable',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketListUsable'->new($_) };

declare 'RepeatedBackendBucketListUsable',
    as ArrayRef[BackendBucketListUsable()];

coerce 'RepeatedBackendBucketListUsable',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketListUsable'->new($_) } @$_ ] };

declare 'MapStringBackendBucketListUsable',
    as HashRef[BackendBucketListUsable()];

declare 'BackendBucketParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketParams'];

coerce 'BackendBucketParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketParams'->new($_) };

declare 'RepeatedBackendBucketParams',
    as ArrayRef[BackendBucketParams()];

coerce 'RepeatedBackendBucketParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketParams'->new($_) } @$_ ] };

declare 'MapStringBackendBucketParams',
    as HashRef[BackendBucketParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'BackendBucketUsedBy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketUsedBy'];

coerce 'BackendBucketUsedBy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketUsedBy'->new($_) };

declare 'RepeatedBackendBucketUsedBy',
    as ArrayRef[BackendBucketUsedBy()];

coerce 'RepeatedBackendBucketUsedBy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketUsedBy'->new($_) } @$_ ] };

declare 'MapStringBackendBucketUsedBy',
    as HashRef[BackendBucketUsedBy()];

declare 'BackendBucketsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendBucketsScopedList'];

coerce 'BackendBucketsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendBucketsScopedList'->new($_) };

declare 'RepeatedBackendBucketsScopedList',
    as ArrayRef[BackendBucketsScopedList()];

coerce 'RepeatedBackendBucketsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendBucketsScopedList'->new($_) } @$_ ] };

declare 'MapStringBackendBucketsScopedList',
    as HashRef[BackendBucketsScopedList()];

declare 'BackendCustomMetric',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendCustomMetric'];

coerce 'BackendCustomMetric',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendCustomMetric'->new($_) };

declare 'RepeatedBackendCustomMetric',
    as ArrayRef[BackendCustomMetric()];

coerce 'RepeatedBackendCustomMetric',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendCustomMetric'->new($_) } @$_ ] };

declare 'MapStringBackendCustomMetric',
    as HashRef[BackendCustomMetric()];

declare 'BackendService',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendService'];

coerce 'BackendService',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendService'->new($_) };

declare 'RepeatedBackendService',
    as ArrayRef[BackendService()];

coerce 'RepeatedBackendService',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendService'->new($_) } @$_ ] };

declare 'MapStringBackendService',
    as HashRef[BackendService()];

declare 'CompressionMode',
    as (Int | Str);

declare 'ExternalManagedMigrationState',
    as (Int | Str);

declare 'IpAddressSelectionPolicy',
    as (Int | Str);

declare 'LoadBalancingScheme',
    as (Int | Str);

declare 'LocalityLbPolicy',
    as (Int | Str);

declare 'Protocol',
    as (Int | Str);

declare 'SessionAffinity',
    as (Int | Str);

declare 'MetadatasEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendService::MetadatasEntry'];

coerce 'MetadatasEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendService::MetadatasEntry'->new($_) };

declare 'RepeatedMetadatasEntry',
    as ArrayRef[MetadatasEntry()];

coerce 'RepeatedMetadatasEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendService::MetadatasEntry'->new($_) } @$_ ] };

declare 'MapStringMetadatasEntry',
    as HashRef[MetadatasEntry()];

declare 'BackendServiceAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceAggregatedList'];

coerce 'BackendServiceAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceAggregatedList'->new($_) };

declare 'RepeatedBackendServiceAggregatedList',
    as ArrayRef[BackendServiceAggregatedList()];

coerce 'RepeatedBackendServiceAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceAggregatedList'->new($_) } @$_ ] };

declare 'MapStringBackendServiceAggregatedList',
    as HashRef[BackendServiceAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'BackendServiceCdnPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicy'];

coerce 'BackendServiceCdnPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicy'->new($_) };

declare 'RepeatedBackendServiceCdnPolicy',
    as ArrayRef[BackendServiceCdnPolicy()];

coerce 'RepeatedBackendServiceCdnPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceCdnPolicy',
    as HashRef[BackendServiceCdnPolicy()];

declare 'CacheMode',
    as (Int | Str);

declare 'BackendServiceCdnPolicyBypassCacheOnRequestHeader',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicyBypassCacheOnRequestHeader'];

coerce 'BackendServiceCdnPolicyBypassCacheOnRequestHeader',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicyBypassCacheOnRequestHeader'->new($_) };

declare 'RepeatedBackendServiceCdnPolicyBypassCacheOnRequestHeader',
    as ArrayRef[BackendServiceCdnPolicyBypassCacheOnRequestHeader()];

coerce 'RepeatedBackendServiceCdnPolicyBypassCacheOnRequestHeader',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicyBypassCacheOnRequestHeader'->new($_) } @$_ ] };

declare 'MapStringBackendServiceCdnPolicyBypassCacheOnRequestHeader',
    as HashRef[BackendServiceCdnPolicyBypassCacheOnRequestHeader()];

declare 'BackendServiceCdnPolicyNegativeCachingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicyNegativeCachingPolicy'];

coerce 'BackendServiceCdnPolicyNegativeCachingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicyNegativeCachingPolicy'->new($_) };

declare 'RepeatedBackendServiceCdnPolicyNegativeCachingPolicy',
    as ArrayRef[BackendServiceCdnPolicyNegativeCachingPolicy()];

coerce 'RepeatedBackendServiceCdnPolicyNegativeCachingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceCdnPolicyNegativeCachingPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceCdnPolicyNegativeCachingPolicy',
    as HashRef[BackendServiceCdnPolicyNegativeCachingPolicy()];

declare 'BackendServiceConnectionTrackingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceConnectionTrackingPolicy'];

coerce 'BackendServiceConnectionTrackingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceConnectionTrackingPolicy'->new($_) };

declare 'RepeatedBackendServiceConnectionTrackingPolicy',
    as ArrayRef[BackendServiceConnectionTrackingPolicy()];

coerce 'RepeatedBackendServiceConnectionTrackingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceConnectionTrackingPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceConnectionTrackingPolicy',
    as HashRef[BackendServiceConnectionTrackingPolicy()];

declare 'ConnectionPersistenceOnUnhealthyBackends',
    as (Int | Str);

declare 'TrackingMode',
    as (Int | Str);

declare 'BackendServiceCustomMetric',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceCustomMetric'];

coerce 'BackendServiceCustomMetric',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceCustomMetric'->new($_) };

declare 'RepeatedBackendServiceCustomMetric',
    as ArrayRef[BackendServiceCustomMetric()];

coerce 'RepeatedBackendServiceCustomMetric',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceCustomMetric'->new($_) } @$_ ] };

declare 'MapStringBackendServiceCustomMetric',
    as HashRef[BackendServiceCustomMetric()];

declare 'BackendServiceFailoverPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceFailoverPolicy'];

coerce 'BackendServiceFailoverPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceFailoverPolicy'->new($_) };

declare 'RepeatedBackendServiceFailoverPolicy',
    as ArrayRef[BackendServiceFailoverPolicy()];

coerce 'RepeatedBackendServiceFailoverPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceFailoverPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceFailoverPolicy',
    as HashRef[BackendServiceFailoverPolicy()];

declare 'BackendServiceGroupHealth',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceGroupHealth'];

coerce 'BackendServiceGroupHealth',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceGroupHealth'->new($_) };

declare 'RepeatedBackendServiceGroupHealth',
    as ArrayRef[BackendServiceGroupHealth()];

coerce 'RepeatedBackendServiceGroupHealth',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceGroupHealth'->new($_) } @$_ ] };

declare 'MapStringBackendServiceGroupHealth',
    as HashRef[BackendServiceGroupHealth()];

declare 'AnnotationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceGroupHealth::AnnotationsEntry'];

coerce 'AnnotationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceGroupHealth::AnnotationsEntry'->new($_) };

declare 'RepeatedAnnotationsEntry',
    as ArrayRef[AnnotationsEntry()];

coerce 'RepeatedAnnotationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceGroupHealth::AnnotationsEntry'->new($_) } @$_ ] };

declare 'MapStringAnnotationsEntry',
    as HashRef[AnnotationsEntry()];

declare 'BackendServiceHAPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicy'];

coerce 'BackendServiceHAPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicy'->new($_) };

declare 'RepeatedBackendServiceHAPolicy',
    as ArrayRef[BackendServiceHAPolicy()];

coerce 'RepeatedBackendServiceHAPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceHAPolicy',
    as HashRef[BackendServiceHAPolicy()];

declare 'FastIPMove',
    as (Int | Str);

declare 'BackendServiceHAPolicyLeader',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicyLeader'];

coerce 'BackendServiceHAPolicyLeader',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicyLeader'->new($_) };

declare 'RepeatedBackendServiceHAPolicyLeader',
    as ArrayRef[BackendServiceHAPolicyLeader()];

coerce 'RepeatedBackendServiceHAPolicyLeader',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicyLeader'->new($_) } @$_ ] };

declare 'MapStringBackendServiceHAPolicyLeader',
    as HashRef[BackendServiceHAPolicyLeader()];

declare 'BackendServiceHAPolicyLeaderNetworkEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicyLeaderNetworkEndpoint'];

coerce 'BackendServiceHAPolicyLeaderNetworkEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicyLeaderNetworkEndpoint'->new($_) };

declare 'RepeatedBackendServiceHAPolicyLeaderNetworkEndpoint',
    as ArrayRef[BackendServiceHAPolicyLeaderNetworkEndpoint()];

coerce 'RepeatedBackendServiceHAPolicyLeaderNetworkEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceHAPolicyLeaderNetworkEndpoint'->new($_) } @$_ ] };

declare 'MapStringBackendServiceHAPolicyLeaderNetworkEndpoint',
    as HashRef[BackendServiceHAPolicyLeaderNetworkEndpoint()];

declare 'BackendServiceHttpCookie',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceHttpCookie'];

coerce 'BackendServiceHttpCookie',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceHttpCookie'->new($_) };

declare 'RepeatedBackendServiceHttpCookie',
    as ArrayRef[BackendServiceHttpCookie()];

coerce 'RepeatedBackendServiceHttpCookie',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceHttpCookie'->new($_) } @$_ ] };

declare 'MapStringBackendServiceHttpCookie',
    as HashRef[BackendServiceHttpCookie()];

declare 'BackendServiceIAP',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceIAP'];

coerce 'BackendServiceIAP',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceIAP'->new($_) };

declare 'RepeatedBackendServiceIAP',
    as ArrayRef[BackendServiceIAP()];

coerce 'RepeatedBackendServiceIAP',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceIAP'->new($_) } @$_ ] };

declare 'MapStringBackendServiceIAP',
    as HashRef[BackendServiceIAP()];

declare 'BackendServiceList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceList'];

coerce 'BackendServiceList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceList'->new($_) };

declare 'RepeatedBackendServiceList',
    as ArrayRef[BackendServiceList()];

coerce 'RepeatedBackendServiceList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceList'->new($_) } @$_ ] };

declare 'MapStringBackendServiceList',
    as HashRef[BackendServiceList()];

declare 'BackendServiceListUsable',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceListUsable'];

coerce 'BackendServiceListUsable',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceListUsable'->new($_) };

declare 'RepeatedBackendServiceListUsable',
    as ArrayRef[BackendServiceListUsable()];

coerce 'RepeatedBackendServiceListUsable',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceListUsable'->new($_) } @$_ ] };

declare 'MapStringBackendServiceListUsable',
    as HashRef[BackendServiceListUsable()];

declare 'BackendServiceLocalityLoadBalancingPolicyConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfig'];

coerce 'BackendServiceLocalityLoadBalancingPolicyConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfig'->new($_) };

declare 'RepeatedBackendServiceLocalityLoadBalancingPolicyConfig',
    as ArrayRef[BackendServiceLocalityLoadBalancingPolicyConfig()];

coerce 'RepeatedBackendServiceLocalityLoadBalancingPolicyConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfig'->new($_) } @$_ ] };

declare 'MapStringBackendServiceLocalityLoadBalancingPolicyConfig',
    as HashRef[BackendServiceLocalityLoadBalancingPolicyConfig()];

declare 'BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy'];

coerce 'BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy'->new($_) };

declare 'RepeatedBackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy',
    as ArrayRef[BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy()];

coerce 'RepeatedBackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy',
    as HashRef[BackendServiceLocalityLoadBalancingPolicyConfigCustomPolicy()];

declare 'BackendServiceLocalityLoadBalancingPolicyConfigPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfigPolicy'];

coerce 'BackendServiceLocalityLoadBalancingPolicyConfigPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfigPolicy'->new($_) };

declare 'RepeatedBackendServiceLocalityLoadBalancingPolicyConfigPolicy',
    as ArrayRef[BackendServiceLocalityLoadBalancingPolicyConfigPolicy()];

coerce 'RepeatedBackendServiceLocalityLoadBalancingPolicyConfigPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceLocalityLoadBalancingPolicyConfigPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceLocalityLoadBalancingPolicyConfigPolicy',
    as HashRef[BackendServiceLocalityLoadBalancingPolicyConfigPolicy()];

declare 'Name',
    as (Int | Str);

declare 'BackendServiceLogConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceLogConfig'];

coerce 'BackendServiceLogConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceLogConfig'->new($_) };

declare 'RepeatedBackendServiceLogConfig',
    as ArrayRef[BackendServiceLogConfig()];

coerce 'RepeatedBackendServiceLogConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceLogConfig'->new($_) } @$_ ] };

declare 'MapStringBackendServiceLogConfig',
    as HashRef[BackendServiceLogConfig()];

declare 'OptionalMode',
    as (Int | Str);

declare 'BackendServiceLogConfigLoggingHttpHeader',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceLogConfigLoggingHttpHeader'];

coerce 'BackendServiceLogConfigLoggingHttpHeader',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceLogConfigLoggingHttpHeader'->new($_) };

declare 'RepeatedBackendServiceLogConfigLoggingHttpHeader',
    as ArrayRef[BackendServiceLogConfigLoggingHttpHeader()];

coerce 'RepeatedBackendServiceLogConfigLoggingHttpHeader',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceLogConfigLoggingHttpHeader'->new($_) } @$_ ] };

declare 'MapStringBackendServiceLogConfigLoggingHttpHeader',
    as HashRef[BackendServiceLogConfigLoggingHttpHeader()];

declare 'BackendServiceNetworkPassThroughLbTrafficPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceNetworkPassThroughLbTrafficPolicy'];

coerce 'BackendServiceNetworkPassThroughLbTrafficPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceNetworkPassThroughLbTrafficPolicy'->new($_) };

declare 'RepeatedBackendServiceNetworkPassThroughLbTrafficPolicy',
    as ArrayRef[BackendServiceNetworkPassThroughLbTrafficPolicy()];

coerce 'RepeatedBackendServiceNetworkPassThroughLbTrafficPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceNetworkPassThroughLbTrafficPolicy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceNetworkPassThroughLbTrafficPolicy',
    as HashRef[BackendServiceNetworkPassThroughLbTrafficPolicy()];

declare 'BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity'];

coerce 'BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity'->new($_) };

declare 'RepeatedBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity',
    as ArrayRef[BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity()];

coerce 'RepeatedBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity'->new($_) } @$_ ] };

declare 'MapStringBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity',
    as HashRef[BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity()];

declare 'Spillover',
    as (Int | Str);

declare 'BackendServiceOrchestrationInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceOrchestrationInfo'];

coerce 'BackendServiceOrchestrationInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceOrchestrationInfo'->new($_) };

declare 'RepeatedBackendServiceOrchestrationInfo',
    as ArrayRef[BackendServiceOrchestrationInfo()];

coerce 'RepeatedBackendServiceOrchestrationInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceOrchestrationInfo'->new($_) } @$_ ] };

declare 'MapStringBackendServiceOrchestrationInfo',
    as HashRef[BackendServiceOrchestrationInfo()];

declare 'BackendServiceParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceParams'];

coerce 'BackendServiceParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceParams'->new($_) };

declare 'RepeatedBackendServiceParams',
    as ArrayRef[BackendServiceParams()];

coerce 'RepeatedBackendServiceParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceParams'->new($_) } @$_ ] };

declare 'MapStringBackendServiceParams',
    as HashRef[BackendServiceParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'BackendServiceReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceReference'];

coerce 'BackendServiceReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceReference'->new($_) };

declare 'RepeatedBackendServiceReference',
    as ArrayRef[BackendServiceReference()];

coerce 'RepeatedBackendServiceReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceReference'->new($_) } @$_ ] };

declare 'MapStringBackendServiceReference',
    as HashRef[BackendServiceReference()];

declare 'BackendServiceTlsSettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceTlsSettings'];

coerce 'BackendServiceTlsSettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceTlsSettings'->new($_) };

declare 'RepeatedBackendServiceTlsSettings',
    as ArrayRef[BackendServiceTlsSettings()];

coerce 'RepeatedBackendServiceTlsSettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceTlsSettings'->new($_) } @$_ ] };

declare 'MapStringBackendServiceTlsSettings',
    as HashRef[BackendServiceTlsSettings()];

declare 'BackendServiceTlsSettingsSubjectAltName',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceTlsSettingsSubjectAltName'];

coerce 'BackendServiceTlsSettingsSubjectAltName',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceTlsSettingsSubjectAltName'->new($_) };

declare 'RepeatedBackendServiceTlsSettingsSubjectAltName',
    as ArrayRef[BackendServiceTlsSettingsSubjectAltName()];

coerce 'RepeatedBackendServiceTlsSettingsSubjectAltName',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceTlsSettingsSubjectAltName'->new($_) } @$_ ] };

declare 'MapStringBackendServiceTlsSettingsSubjectAltName',
    as HashRef[BackendServiceTlsSettingsSubjectAltName()];

declare 'BackendServiceUsedBy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServiceUsedBy'];

coerce 'BackendServiceUsedBy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServiceUsedBy'->new($_) };

declare 'RepeatedBackendServiceUsedBy',
    as ArrayRef[BackendServiceUsedBy()];

coerce 'RepeatedBackendServiceUsedBy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServiceUsedBy'->new($_) } @$_ ] };

declare 'MapStringBackendServiceUsedBy',
    as HashRef[BackendServiceUsedBy()];

declare 'BackendServicesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BackendServicesScopedList'];

coerce 'BackendServicesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BackendServicesScopedList'->new($_) };

declare 'RepeatedBackendServicesScopedList',
    as ArrayRef[BackendServicesScopedList()];

coerce 'RepeatedBackendServicesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BackendServicesScopedList'->new($_) } @$_ ] };

declare 'MapStringBackendServicesScopedList',
    as HashRef[BackendServicesScopedList()];

declare 'BfdPacket',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BfdPacket'];

coerce 'BfdPacket',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BfdPacket'->new($_) };

declare 'RepeatedBfdPacket',
    as ArrayRef[BfdPacket()];

coerce 'RepeatedBfdPacket',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BfdPacket'->new($_) } @$_ ] };

declare 'MapStringBfdPacket',
    as HashRef[BfdPacket()];

declare 'Diagnostic',
    as (Int | Str);

declare 'State',
    as (Int | Str);

declare 'BfdStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BfdStatus'];

coerce 'BfdStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BfdStatus'->new($_) };

declare 'RepeatedBfdStatus',
    as ArrayRef[BfdStatus()];

coerce 'RepeatedBfdStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BfdStatus'->new($_) } @$_ ] };

declare 'MapStringBfdStatus',
    as HashRef[BfdStatus()];

declare 'BfdSessionInitializationMode',
    as (Int | Str);

declare 'LocalDiagnostic',
    as (Int | Str);

declare 'LocalState',
    as (Int | Str);

declare 'BfdStatusPacketCounts',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BfdStatusPacketCounts'];

coerce 'BfdStatusPacketCounts',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BfdStatusPacketCounts'->new($_) };

declare 'RepeatedBfdStatusPacketCounts',
    as ArrayRef[BfdStatusPacketCounts()];

coerce 'RepeatedBfdStatusPacketCounts',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BfdStatusPacketCounts'->new($_) } @$_ ] };

declare 'MapStringBfdStatusPacketCounts',
    as HashRef[BfdStatusPacketCounts()];

declare 'BgpRoute',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BgpRoute'];

coerce 'BgpRoute',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BgpRoute'->new($_) };

declare 'RepeatedBgpRoute',
    as ArrayRef[BgpRoute()];

coerce 'RepeatedBgpRoute',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BgpRoute'->new($_) } @$_ ] };

declare 'MapStringBgpRoute',
    as HashRef[BgpRoute()];

declare 'Origin',
    as (Int | Str);

declare 'BgpRouteAsPath',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BgpRouteAsPath'];

coerce 'BgpRouteAsPath',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BgpRouteAsPath'->new($_) };

declare 'RepeatedBgpRouteAsPath',
    as ArrayRef[BgpRouteAsPath()];

coerce 'RepeatedBgpRouteAsPath',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BgpRouteAsPath'->new($_) } @$_ ] };

declare 'MapStringBgpRouteAsPath',
    as HashRef[BgpRouteAsPath()];

declare 'Type',
    as (Int | Str);

declare 'BgpRouteNetworkLayerReachabilityInformation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BgpRouteNetworkLayerReachabilityInformation'];

coerce 'BgpRouteNetworkLayerReachabilityInformation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BgpRouteNetworkLayerReachabilityInformation'->new($_) };

declare 'RepeatedBgpRouteNetworkLayerReachabilityInformation',
    as ArrayRef[BgpRouteNetworkLayerReachabilityInformation()];

coerce 'RepeatedBgpRouteNetworkLayerReachabilityInformation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BgpRouteNetworkLayerReachabilityInformation'->new($_) } @$_ ] };

declare 'MapStringBgpRouteNetworkLayerReachabilityInformation',
    as HashRef[BgpRouteNetworkLayerReachabilityInformation()];

declare 'Binding',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Binding'];

coerce 'Binding',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Binding'->new($_) };

declare 'RepeatedBinding',
    as ArrayRef[Binding()];

coerce 'RepeatedBinding',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Binding'->new($_) } @$_ ] };

declare 'MapStringBinding',
    as HashRef[Binding()];

declare 'BulkInsertDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertDiskRequest'];

coerce 'BulkInsertDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertDiskRequest'->new($_) };

declare 'RepeatedBulkInsertDiskRequest',
    as ArrayRef[BulkInsertDiskRequest()];

coerce 'RepeatedBulkInsertDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertDiskRequest'->new($_) } @$_ ] };

declare 'MapStringBulkInsertDiskRequest',
    as HashRef[BulkInsertDiskRequest()];

declare 'BulkInsertDiskResource',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertDiskResource'];

coerce 'BulkInsertDiskResource',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertDiskResource'->new($_) };

declare 'RepeatedBulkInsertDiskResource',
    as ArrayRef[BulkInsertDiskResource()];

coerce 'RepeatedBulkInsertDiskResource',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertDiskResource'->new($_) } @$_ ] };

declare 'MapStringBulkInsertDiskResource',
    as HashRef[BulkInsertDiskResource()];

declare 'BulkInsertInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertInstanceRequest'];

coerce 'BulkInsertInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceRequest'->new($_) };

declare 'RepeatedBulkInsertInstanceRequest',
    as ArrayRef[BulkInsertInstanceRequest()];

coerce 'RepeatedBulkInsertInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringBulkInsertInstanceRequest',
    as HashRef[BulkInsertInstanceRequest()];

declare 'BulkInsertInstanceResource',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResource'];

coerce 'BulkInsertInstanceResource',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResource'->new($_) };

declare 'RepeatedBulkInsertInstanceResource',
    as ArrayRef[BulkInsertInstanceResource()];

coerce 'RepeatedBulkInsertInstanceResource',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResource'->new($_) } @$_ ] };

declare 'MapStringBulkInsertInstanceResource',
    as HashRef[BulkInsertInstanceResource()];

declare 'PerInstancePropertiesEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResource::PerInstancePropertiesEntry'];

coerce 'PerInstancePropertiesEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResource::PerInstancePropertiesEntry'->new($_) };

declare 'RepeatedPerInstancePropertiesEntry',
    as ArrayRef[PerInstancePropertiesEntry()];

coerce 'RepeatedPerInstancePropertiesEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResource::PerInstancePropertiesEntry'->new($_) } @$_ ] };

declare 'MapStringPerInstancePropertiesEntry',
    as HashRef[PerInstancePropertiesEntry()];

declare 'BulkInsertInstanceResourcePerInstanceProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResourcePerInstanceProperties'];

coerce 'BulkInsertInstanceResourcePerInstanceProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResourcePerInstanceProperties'->new($_) };

declare 'RepeatedBulkInsertInstanceResourcePerInstanceProperties',
    as ArrayRef[BulkInsertInstanceResourcePerInstanceProperties()];

coerce 'RepeatedBulkInsertInstanceResourcePerInstanceProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertInstanceResourcePerInstanceProperties'->new($_) } @$_ ] };

declare 'MapStringBulkInsertInstanceResourcePerInstanceProperties',
    as HashRef[BulkInsertInstanceResourcePerInstanceProperties()];

declare 'BulkInsertOperationStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertOperationStatus'];

coerce 'BulkInsertOperationStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertOperationStatus'->new($_) };

declare 'RepeatedBulkInsertOperationStatus',
    as ArrayRef[BulkInsertOperationStatus()];

coerce 'RepeatedBulkInsertOperationStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertOperationStatus'->new($_) } @$_ ] };

declare 'MapStringBulkInsertOperationStatus',
    as HashRef[BulkInsertOperationStatus()];

declare 'Status',
    as (Int | Str);

declare 'BulkInsertRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertRegionDiskRequest'];

coerce 'BulkInsertRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertRegionDiskRequest'->new($_) };

declare 'RepeatedBulkInsertRegionDiskRequest',
    as ArrayRef[BulkInsertRegionDiskRequest()];

coerce 'RepeatedBulkInsertRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringBulkInsertRegionDiskRequest',
    as HashRef[BulkInsertRegionDiskRequest()];

declare 'BulkInsertRegionInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkInsertRegionInstanceRequest'];

coerce 'BulkInsertRegionInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkInsertRegionInstanceRequest'->new($_) };

declare 'RepeatedBulkInsertRegionInstanceRequest',
    as ArrayRef[BulkInsertRegionInstanceRequest()];

coerce 'RepeatedBulkInsertRegionInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkInsertRegionInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringBulkInsertRegionInstanceRequest',
    as HashRef[BulkInsertRegionInstanceRequest()];

declare 'BulkSetLabelsDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkSetLabelsDiskRequest'];

coerce 'BulkSetLabelsDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkSetLabelsDiskRequest'->new($_) };

declare 'RepeatedBulkSetLabelsDiskRequest',
    as ArrayRef[BulkSetLabelsDiskRequest()];

coerce 'RepeatedBulkSetLabelsDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkSetLabelsDiskRequest'->new($_) } @$_ ] };

declare 'MapStringBulkSetLabelsDiskRequest',
    as HashRef[BulkSetLabelsDiskRequest()];

declare 'BulkSetLabelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkSetLabelsRequest'];

coerce 'BulkSetLabelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkSetLabelsRequest'->new($_) };

declare 'RepeatedBulkSetLabelsRequest',
    as ArrayRef[BulkSetLabelsRequest()];

coerce 'RepeatedBulkSetLabelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkSetLabelsRequest'->new($_) } @$_ ] };

declare 'MapStringBulkSetLabelsRequest',
    as HashRef[BulkSetLabelsRequest()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkSetLabelsRequest::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkSetLabelsRequest::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkSetLabelsRequest::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'BulkZoneSetLabelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BulkZoneSetLabelsRequest'];

coerce 'BulkZoneSetLabelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BulkZoneSetLabelsRequest'->new($_) };

declare 'RepeatedBulkZoneSetLabelsRequest',
    as ArrayRef[BulkZoneSetLabelsRequest()];

coerce 'RepeatedBulkZoneSetLabelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BulkZoneSetLabelsRequest'->new($_) } @$_ ] };

declare 'MapStringBulkZoneSetLabelsRequest',
    as HashRef[BulkZoneSetLabelsRequest()];

declare 'BundledLocalSsds',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::BundledLocalSsds'];

coerce 'BundledLocalSsds',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::BundledLocalSsds'->new($_) };

declare 'RepeatedBundledLocalSsds',
    as ArrayRef[BundledLocalSsds()];

coerce 'RepeatedBundledLocalSsds',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::BundledLocalSsds'->new($_) } @$_ ] };

declare 'MapStringBundledLocalSsds',
    as HashRef[BundledLocalSsds()];

declare 'CacheInvalidationRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CacheInvalidationRule'];

coerce 'CacheInvalidationRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CacheInvalidationRule'->new($_) };

declare 'RepeatedCacheInvalidationRule',
    as ArrayRef[CacheInvalidationRule()];

coerce 'RepeatedCacheInvalidationRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CacheInvalidationRule'->new($_) } @$_ ] };

declare 'MapStringCacheInvalidationRule',
    as HashRef[CacheInvalidationRule()];

declare 'CacheKeyPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CacheKeyPolicy'];

coerce 'CacheKeyPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CacheKeyPolicy'->new($_) };

declare 'RepeatedCacheKeyPolicy',
    as ArrayRef[CacheKeyPolicy()];

coerce 'RepeatedCacheKeyPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CacheKeyPolicy'->new($_) } @$_ ] };

declare 'MapStringCacheKeyPolicy',
    as HashRef[CacheKeyPolicy()];

declare 'CachePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CachePolicy'];

coerce 'CachePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CachePolicy'->new($_) };

declare 'RepeatedCachePolicy',
    as ArrayRef[CachePolicy()];

coerce 'RepeatedCachePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CachePolicy'->new($_) } @$_ ] };

declare 'MapStringCachePolicy',
    as HashRef[CachePolicy()];

declare 'CacheMode',
    as (Int | Str);

declare 'CachePolicyCacheKeyPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CachePolicyCacheKeyPolicy'];

coerce 'CachePolicyCacheKeyPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CachePolicyCacheKeyPolicy'->new($_) };

declare 'RepeatedCachePolicyCacheKeyPolicy',
    as ArrayRef[CachePolicyCacheKeyPolicy()];

coerce 'RepeatedCachePolicyCacheKeyPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CachePolicyCacheKeyPolicy'->new($_) } @$_ ] };

declare 'MapStringCachePolicyCacheKeyPolicy',
    as HashRef[CachePolicyCacheKeyPolicy()];

declare 'CachePolicyNegativeCachingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CachePolicyNegativeCachingPolicy'];

coerce 'CachePolicyNegativeCachingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CachePolicyNegativeCachingPolicy'->new($_) };

declare 'RepeatedCachePolicyNegativeCachingPolicy',
    as ArrayRef[CachePolicyNegativeCachingPolicy()];

coerce 'RepeatedCachePolicyNegativeCachingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CachePolicyNegativeCachingPolicy'->new($_) } @$_ ] };

declare 'MapStringCachePolicyNegativeCachingPolicy',
    as HashRef[CachePolicyNegativeCachingPolicy()];

declare 'CalendarModeAdviceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRequest'];

coerce 'CalendarModeAdviceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRequest'->new($_) };

declare 'RepeatedCalendarModeAdviceRequest',
    as ArrayRef[CalendarModeAdviceRequest()];

coerce 'RepeatedCalendarModeAdviceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRequest'->new($_) } @$_ ] };

declare 'MapStringCalendarModeAdviceRequest',
    as HashRef[CalendarModeAdviceRequest()];

declare 'FutureResourcesSpecsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRequest::FutureResourcesSpecsEntry'];

coerce 'FutureResourcesSpecsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRequest::FutureResourcesSpecsEntry'->new($_) };

declare 'RepeatedFutureResourcesSpecsEntry',
    as ArrayRef[FutureResourcesSpecsEntry()];

coerce 'RepeatedFutureResourcesSpecsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRequest::FutureResourcesSpecsEntry'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpecsEntry',
    as HashRef[FutureResourcesSpecsEntry()];

declare 'CalendarModeAdviceResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CalendarModeAdviceResponse'];

coerce 'CalendarModeAdviceResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceResponse'->new($_) };

declare 'RepeatedCalendarModeAdviceResponse',
    as ArrayRef[CalendarModeAdviceResponse()];

coerce 'RepeatedCalendarModeAdviceResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceResponse'->new($_) } @$_ ] };

declare 'MapStringCalendarModeAdviceResponse',
    as HashRef[CalendarModeAdviceResponse()];

declare 'CalendarModeAdviceRpcRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRpcRequest'];

coerce 'CalendarModeAdviceRpcRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRpcRequest'->new($_) };

declare 'RepeatedCalendarModeAdviceRpcRequest',
    as ArrayRef[CalendarModeAdviceRpcRequest()];

coerce 'RepeatedCalendarModeAdviceRpcRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CalendarModeAdviceRpcRequest'->new($_) } @$_ ] };

declare 'MapStringCalendarModeAdviceRpcRequest',
    as HashRef[CalendarModeAdviceRpcRequest()];

declare 'CalendarModeRecommendation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CalendarModeRecommendation'];

coerce 'CalendarModeRecommendation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CalendarModeRecommendation'->new($_) };

declare 'RepeatedCalendarModeRecommendation',
    as ArrayRef[CalendarModeRecommendation()];

coerce 'RepeatedCalendarModeRecommendation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CalendarModeRecommendation'->new($_) } @$_ ] };

declare 'MapStringCalendarModeRecommendation',
    as HashRef[CalendarModeRecommendation()];

declare 'RecommendationsPerSpecEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CalendarModeRecommendation::RecommendationsPerSpecEntry'];

coerce 'RecommendationsPerSpecEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CalendarModeRecommendation::RecommendationsPerSpecEntry'->new($_) };

declare 'RepeatedRecommendationsPerSpecEntry',
    as ArrayRef[RecommendationsPerSpecEntry()];

coerce 'RepeatedRecommendationsPerSpecEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CalendarModeRecommendation::RecommendationsPerSpecEntry'->new($_) } @$_ ] };

declare 'MapStringRecommendationsPerSpecEntry',
    as HashRef[RecommendationsPerSpecEntry()];

declare 'CancelFutureReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CancelFutureReservationRequest'];

coerce 'CancelFutureReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CancelFutureReservationRequest'->new($_) };

declare 'RepeatedCancelFutureReservationRequest',
    as ArrayRef[CancelFutureReservationRequest()];

coerce 'RepeatedCancelFutureReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CancelFutureReservationRequest'->new($_) } @$_ ] };

declare 'MapStringCancelFutureReservationRequest',
    as HashRef[CancelFutureReservationRequest()];

declare 'CancelInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CancelInstanceGroupManagerResizeRequestRequest'];

coerce 'CancelInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CancelInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedCancelInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[CancelInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedCancelInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CancelInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringCancelInstanceGroupManagerResizeRequestRequest',
    as HashRef[CancelInstanceGroupManagerResizeRequestRequest()];

declare 'CancelRegionInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CancelRegionInstanceGroupManagerResizeRequestRequest'];

coerce 'CancelRegionInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CancelRegionInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedCancelRegionInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[CancelRegionInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedCancelRegionInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CancelRegionInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringCancelRegionInstanceGroupManagerResizeRequestRequest',
    as HashRef[CancelRegionInstanceGroupManagerResizeRequestRequest()];

declare 'CancelRequestRemovePeeringNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CancelRequestRemovePeeringNetworkRequest'];

coerce 'CancelRequestRemovePeeringNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CancelRequestRemovePeeringNetworkRequest'->new($_) };

declare 'RepeatedCancelRequestRemovePeeringNetworkRequest',
    as ArrayRef[CancelRequestRemovePeeringNetworkRequest()];

coerce 'RepeatedCancelRequestRemovePeeringNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CancelRequestRemovePeeringNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringCancelRequestRemovePeeringNetworkRequest',
    as HashRef[CancelRequestRemovePeeringNetworkRequest()];

declare 'CancelRolloutRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CancelRolloutRequest'];

coerce 'CancelRolloutRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CancelRolloutRequest'->new($_) };

declare 'RepeatedCancelRolloutRequest',
    as ArrayRef[CancelRolloutRequest()];

coerce 'RepeatedCancelRolloutRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CancelRolloutRequest'->new($_) } @$_ ] };

declare 'MapStringCancelRolloutRequest',
    as HashRef[CancelRolloutRequest()];

declare 'CircuitBreakers',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CircuitBreakers'];

coerce 'CircuitBreakers',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CircuitBreakers'->new($_) };

declare 'RepeatedCircuitBreakers',
    as ArrayRef[CircuitBreakers()];

coerce 'RepeatedCircuitBreakers',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CircuitBreakers'->new($_) } @$_ ] };

declare 'MapStringCircuitBreakers',
    as HashRef[CircuitBreakers()];

declare 'CloneRulesFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CloneRulesFirewallPolicyRequest'];

coerce 'CloneRulesFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CloneRulesFirewallPolicyRequest'->new($_) };

declare 'RepeatedCloneRulesFirewallPolicyRequest',
    as ArrayRef[CloneRulesFirewallPolicyRequest()];

coerce 'RepeatedCloneRulesFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CloneRulesFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringCloneRulesFirewallPolicyRequest',
    as HashRef[CloneRulesFirewallPolicyRequest()];

declare 'CloneRulesNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CloneRulesNetworkFirewallPolicyRequest'];

coerce 'CloneRulesNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CloneRulesNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedCloneRulesNetworkFirewallPolicyRequest',
    as ArrayRef[CloneRulesNetworkFirewallPolicyRequest()];

coerce 'RepeatedCloneRulesNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CloneRulesNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringCloneRulesNetworkFirewallPolicyRequest',
    as HashRef[CloneRulesNetworkFirewallPolicyRequest()];

declare 'CloneRulesRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CloneRulesRegionNetworkFirewallPolicyRequest'];

coerce 'CloneRulesRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CloneRulesRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedCloneRulesRegionNetworkFirewallPolicyRequest',
    as ArrayRef[CloneRulesRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedCloneRulesRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CloneRulesRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringCloneRulesRegionNetworkFirewallPolicyRequest',
    as HashRef[CloneRulesRegionNetworkFirewallPolicyRequest()];

declare 'Commitment',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Commitment'];

coerce 'Commitment',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Commitment'->new($_) };

declare 'RepeatedCommitment',
    as ArrayRef[Commitment()];

coerce 'RepeatedCommitment',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Commitment'->new($_) } @$_ ] };

declare 'MapStringCommitment',
    as HashRef[Commitment()];

declare 'Category',
    as (Int | Str);

declare 'Plan',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'CommitmentAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CommitmentAggregatedList'];

coerce 'CommitmentAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CommitmentAggregatedList'->new($_) };

declare 'RepeatedCommitmentAggregatedList',
    as ArrayRef[CommitmentAggregatedList()];

coerce 'RepeatedCommitmentAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CommitmentAggregatedList'->new($_) } @$_ ] };

declare 'MapStringCommitmentAggregatedList',
    as HashRef[CommitmentAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CommitmentAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CommitmentAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CommitmentAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'CommitmentList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CommitmentList'];

coerce 'CommitmentList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CommitmentList'->new($_) };

declare 'RepeatedCommitmentList',
    as ArrayRef[CommitmentList()];

coerce 'RepeatedCommitmentList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CommitmentList'->new($_) } @$_ ] };

declare 'MapStringCommitmentList',
    as HashRef[CommitmentList()];

declare 'CommitmentParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CommitmentParams'];

coerce 'CommitmentParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CommitmentParams'->new($_) };

declare 'RepeatedCommitmentParams',
    as ArrayRef[CommitmentParams()];

coerce 'RepeatedCommitmentParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CommitmentParams'->new($_) } @$_ ] };

declare 'MapStringCommitmentParams',
    as HashRef[CommitmentParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CommitmentParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CommitmentParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CommitmentParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'CommitmentResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CommitmentResourceStatus'];

coerce 'CommitmentResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CommitmentResourceStatus'->new($_) };

declare 'RepeatedCommitmentResourceStatus',
    as ArrayRef[CommitmentResourceStatus()];

coerce 'RepeatedCommitmentResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CommitmentResourceStatus'->new($_) } @$_ ] };

declare 'MapStringCommitmentResourceStatus',
    as HashRef[CommitmentResourceStatus()];

declare 'CommitmentsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CommitmentsScopedList'];

coerce 'CommitmentsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CommitmentsScopedList'->new($_) };

declare 'RepeatedCommitmentsScopedList',
    as ArrayRef[CommitmentsScopedList()];

coerce 'RepeatedCommitmentsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CommitmentsScopedList'->new($_) } @$_ ] };

declare 'MapStringCommitmentsScopedList',
    as HashRef[CommitmentsScopedList()];

declare 'CompositeHealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CompositeHealthCheck'];

coerce 'CompositeHealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheck'->new($_) };

declare 'RepeatedCompositeHealthCheck',
    as ArrayRef[CompositeHealthCheck()];

coerce 'RepeatedCompositeHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheck'->new($_) } @$_ ] };

declare 'MapStringCompositeHealthCheck',
    as HashRef[CompositeHealthCheck()];

declare 'CompositeHealthCheckAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CompositeHealthCheckAggregatedList'];

coerce 'CompositeHealthCheckAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckAggregatedList'->new($_) };

declare 'RepeatedCompositeHealthCheckAggregatedList',
    as ArrayRef[CompositeHealthCheckAggregatedList()];

coerce 'RepeatedCompositeHealthCheckAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckAggregatedList'->new($_) } @$_ ] };

declare 'MapStringCompositeHealthCheckAggregatedList',
    as HashRef[CompositeHealthCheckAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CompositeHealthCheckAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'CompositeHealthCheckHealth',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CompositeHealthCheckHealth'];

coerce 'CompositeHealthCheckHealth',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckHealth'->new($_) };

declare 'RepeatedCompositeHealthCheckHealth',
    as ArrayRef[CompositeHealthCheckHealth()];

coerce 'RepeatedCompositeHealthCheckHealth',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckHealth'->new($_) } @$_ ] };

declare 'MapStringCompositeHealthCheckHealth',
    as HashRef[CompositeHealthCheckHealth()];

declare 'HealthState',
    as (Int | Str);

declare 'CompositeHealthCheckList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CompositeHealthCheckList'];

coerce 'CompositeHealthCheckList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckList'->new($_) };

declare 'RepeatedCompositeHealthCheckList',
    as ArrayRef[CompositeHealthCheckList()];

coerce 'RepeatedCompositeHealthCheckList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CompositeHealthCheckList'->new($_) } @$_ ] };

declare 'MapStringCompositeHealthCheckList',
    as HashRef[CompositeHealthCheckList()];

declare 'CompositeHealthChecksGetHealthResponseHealthSourceHealth',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CompositeHealthChecksGetHealthResponseHealthSourceHealth'];

coerce 'CompositeHealthChecksGetHealthResponseHealthSourceHealth',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CompositeHealthChecksGetHealthResponseHealthSourceHealth'->new($_) };

declare 'RepeatedCompositeHealthChecksGetHealthResponseHealthSourceHealth',
    as ArrayRef[CompositeHealthChecksGetHealthResponseHealthSourceHealth()];

coerce 'RepeatedCompositeHealthChecksGetHealthResponseHealthSourceHealth',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CompositeHealthChecksGetHealthResponseHealthSourceHealth'->new($_) } @$_ ] };

declare 'MapStringCompositeHealthChecksGetHealthResponseHealthSourceHealth',
    as HashRef[CompositeHealthChecksGetHealthResponseHealthSourceHealth()];

declare 'HealthState',
    as (Int | Str);

declare 'CompositeHealthChecksScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CompositeHealthChecksScopedList'];

coerce 'CompositeHealthChecksScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CompositeHealthChecksScopedList'->new($_) };

declare 'RepeatedCompositeHealthChecksScopedList',
    as ArrayRef[CompositeHealthChecksScopedList()];

coerce 'RepeatedCompositeHealthChecksScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CompositeHealthChecksScopedList'->new($_) } @$_ ] };

declare 'MapStringCompositeHealthChecksScopedList',
    as HashRef[CompositeHealthChecksScopedList()];

declare 'ConfidentialInstanceConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ConfidentialInstanceConfig'];

coerce 'ConfidentialInstanceConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ConfidentialInstanceConfig'->new($_) };

declare 'RepeatedConfidentialInstanceConfig',
    as ArrayRef[ConfidentialInstanceConfig()];

coerce 'RepeatedConfidentialInstanceConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ConfidentialInstanceConfig'->new($_) } @$_ ] };

declare 'MapStringConfidentialInstanceConfig',
    as HashRef[ConfidentialInstanceConfig()];

declare 'ConfidentialInstanceType',
    as (Int | Str);

declare 'ConnectionDraining',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ConnectionDraining'];

coerce 'ConnectionDraining',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ConnectionDraining'->new($_) };

declare 'RepeatedConnectionDraining',
    as ArrayRef[ConnectionDraining()];

coerce 'RepeatedConnectionDraining',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ConnectionDraining'->new($_) } @$_ ] };

declare 'MapStringConnectionDraining',
    as HashRef[ConnectionDraining()];

declare 'ConsistentHashLoadBalancerSettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ConsistentHashLoadBalancerSettings'];

coerce 'ConsistentHashLoadBalancerSettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ConsistentHashLoadBalancerSettings'->new($_) };

declare 'RepeatedConsistentHashLoadBalancerSettings',
    as ArrayRef[ConsistentHashLoadBalancerSettings()];

coerce 'RepeatedConsistentHashLoadBalancerSettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ConsistentHashLoadBalancerSettings'->new($_) } @$_ ] };

declare 'MapStringConsistentHashLoadBalancerSettings',
    as HashRef[ConsistentHashLoadBalancerSettings()];

declare 'ConsistentHashLoadBalancerSettingsHttpCookie',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ConsistentHashLoadBalancerSettingsHttpCookie'];

coerce 'ConsistentHashLoadBalancerSettingsHttpCookie',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ConsistentHashLoadBalancerSettingsHttpCookie'->new($_) };

declare 'RepeatedConsistentHashLoadBalancerSettingsHttpCookie',
    as ArrayRef[ConsistentHashLoadBalancerSettingsHttpCookie()];

coerce 'RepeatedConsistentHashLoadBalancerSettingsHttpCookie',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ConsistentHashLoadBalancerSettingsHttpCookie'->new($_) } @$_ ] };

declare 'MapStringConsistentHashLoadBalancerSettingsHttpCookie',
    as HashRef[ConsistentHashLoadBalancerSettingsHttpCookie()];

declare 'CopyRulesOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CopyRulesOrganizationSecurityPolicyRequest'];

coerce 'CopyRulesOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CopyRulesOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedCopyRulesOrganizationSecurityPolicyRequest',
    as ArrayRef[CopyRulesOrganizationSecurityPolicyRequest()];

coerce 'RepeatedCopyRulesOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CopyRulesOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringCopyRulesOrganizationSecurityPolicyRequest',
    as HashRef[CopyRulesOrganizationSecurityPolicyRequest()];

declare 'CorsPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CorsPolicy'];

coerce 'CorsPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CorsPolicy'->new($_) };

declare 'RepeatedCorsPolicy',
    as ArrayRef[CorsPolicy()];

coerce 'RepeatedCorsPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CorsPolicy'->new($_) } @$_ ] };

declare 'MapStringCorsPolicy',
    as HashRef[CorsPolicy()];

declare 'CreateInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CreateInstancesInstanceGroupManagerRequest'];

coerce 'CreateInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CreateInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedCreateInstancesInstanceGroupManagerRequest',
    as ArrayRef[CreateInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedCreateInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CreateInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringCreateInstancesInstanceGroupManagerRequest',
    as HashRef[CreateInstancesInstanceGroupManagerRequest()];

declare 'CreateInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CreateInstancesRegionInstanceGroupManagerRequest'];

coerce 'CreateInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CreateInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedCreateInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[CreateInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedCreateInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CreateInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringCreateInstancesRegionInstanceGroupManagerRequest',
    as HashRef[CreateInstancesRegionInstanceGroupManagerRequest()];

declare 'CreateMembersInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CreateMembersInterconnectGroupRequest'];

coerce 'CreateMembersInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CreateMembersInterconnectGroupRequest'->new($_) };

declare 'RepeatedCreateMembersInterconnectGroupRequest',
    as ArrayRef[CreateMembersInterconnectGroupRequest()];

coerce 'RepeatedCreateMembersInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CreateMembersInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringCreateMembersInterconnectGroupRequest',
    as HashRef[CreateMembersInterconnectGroupRequest()];

declare 'CreateSnapshotDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CreateSnapshotDiskRequest'];

coerce 'CreateSnapshotDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CreateSnapshotDiskRequest'->new($_) };

declare 'RepeatedCreateSnapshotDiskRequest',
    as ArrayRef[CreateSnapshotDiskRequest()];

coerce 'RepeatedCreateSnapshotDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CreateSnapshotDiskRequest'->new($_) } @$_ ] };

declare 'MapStringCreateSnapshotDiskRequest',
    as HashRef[CreateSnapshotDiskRequest()];

declare 'CreateSnapshotRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CreateSnapshotRegionDiskRequest'];

coerce 'CreateSnapshotRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CreateSnapshotRegionDiskRequest'->new($_) };

declare 'RepeatedCreateSnapshotRegionDiskRequest',
    as ArrayRef[CreateSnapshotRegionDiskRequest()];

coerce 'RepeatedCreateSnapshotRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CreateSnapshotRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringCreateSnapshotRegionDiskRequest',
    as HashRef[CreateSnapshotRegionDiskRequest()];

declare 'CrossSiteNetwork',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CrossSiteNetwork'];

coerce 'CrossSiteNetwork',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CrossSiteNetwork'->new($_) };

declare 'RepeatedCrossSiteNetwork',
    as ArrayRef[CrossSiteNetwork()];

coerce 'RepeatedCrossSiteNetwork',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CrossSiteNetwork'->new($_) } @$_ ] };

declare 'MapStringCrossSiteNetwork',
    as HashRef[CrossSiteNetwork()];

declare 'CrossSiteNetworkList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CrossSiteNetworkList'];

coerce 'CrossSiteNetworkList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CrossSiteNetworkList'->new($_) };

declare 'RepeatedCrossSiteNetworkList',
    as ArrayRef[CrossSiteNetworkList()];

coerce 'RepeatedCrossSiteNetworkList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CrossSiteNetworkList'->new($_) } @$_ ] };

declare 'MapStringCrossSiteNetworkList',
    as HashRef[CrossSiteNetworkList()];

declare 'CustomErrorResponsePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CustomErrorResponsePolicy'];

coerce 'CustomErrorResponsePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CustomErrorResponsePolicy'->new($_) };

declare 'RepeatedCustomErrorResponsePolicy',
    as ArrayRef[CustomErrorResponsePolicy()];

coerce 'RepeatedCustomErrorResponsePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CustomErrorResponsePolicy'->new($_) } @$_ ] };

declare 'MapStringCustomErrorResponsePolicy',
    as HashRef[CustomErrorResponsePolicy()];

declare 'CustomErrorResponsePolicyCustomErrorResponseRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CustomErrorResponsePolicyCustomErrorResponseRule'];

coerce 'CustomErrorResponsePolicyCustomErrorResponseRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CustomErrorResponsePolicyCustomErrorResponseRule'->new($_) };

declare 'RepeatedCustomErrorResponsePolicyCustomErrorResponseRule',
    as ArrayRef[CustomErrorResponsePolicyCustomErrorResponseRule()];

coerce 'RepeatedCustomErrorResponsePolicyCustomErrorResponseRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CustomErrorResponsePolicyCustomErrorResponseRule'->new($_) } @$_ ] };

declare 'MapStringCustomErrorResponsePolicyCustomErrorResponseRule',
    as HashRef[CustomErrorResponsePolicyCustomErrorResponseRule()];

declare 'CustomerEncryptionKey',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CustomerEncryptionKey'];

coerce 'CustomerEncryptionKey',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CustomerEncryptionKey'->new($_) };

declare 'RepeatedCustomerEncryptionKey',
    as ArrayRef[CustomerEncryptionKey()];

coerce 'RepeatedCustomerEncryptionKey',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CustomerEncryptionKey'->new($_) } @$_ ] };

declare 'MapStringCustomerEncryptionKey',
    as HashRef[CustomerEncryptionKey()];

declare 'CustomerEncryptionKeyProtectedDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::CustomerEncryptionKeyProtectedDisk'];

coerce 'CustomerEncryptionKeyProtectedDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::CustomerEncryptionKeyProtectedDisk'->new($_) };

declare 'RepeatedCustomerEncryptionKeyProtectedDisk',
    as ArrayRef[CustomerEncryptionKeyProtectedDisk()];

coerce 'RepeatedCustomerEncryptionKeyProtectedDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::CustomerEncryptionKeyProtectedDisk'->new($_) } @$_ ] };

declare 'MapStringCustomerEncryptionKeyProtectedDisk',
    as HashRef[CustomerEncryptionKeyProtectedDisk()];

declare 'Data',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Data'];

coerce 'Data',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Data'->new($_) };

declare 'RepeatedData',
    as ArrayRef[Data()];

coerce 'RepeatedData',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Data'->new($_) } @$_ ] };

declare 'MapStringData',
    as HashRef[Data()];

declare 'Date',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Date'];

coerce 'Date',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Date'->new($_) };

declare 'RepeatedDate',
    as ArrayRef[Date()];

coerce 'RepeatedDate',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Date'->new($_) } @$_ ] };

declare 'MapStringDate',
    as HashRef[Date()];

declare 'DateTime',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DateTime'];

coerce 'DateTime',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DateTime'->new($_) };

declare 'RepeatedDateTime',
    as ArrayRef[DateTime()];

coerce 'RepeatedDateTime',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DateTime'->new($_) } @$_ ] };

declare 'MapStringDateTime',
    as HashRef[DateTime()];

declare 'DeleteAccessConfigInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteAccessConfigInstanceRequest'];

coerce 'DeleteAccessConfigInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteAccessConfigInstanceRequest'->new($_) };

declare 'RepeatedDeleteAccessConfigInstanceRequest',
    as ArrayRef[DeleteAccessConfigInstanceRequest()];

coerce 'RepeatedDeleteAccessConfigInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteAccessConfigInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteAccessConfigInstanceRequest',
    as HashRef[DeleteAccessConfigInstanceRequest()];

declare 'DeleteAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteAddressRequest'];

coerce 'DeleteAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteAddressRequest'->new($_) };

declare 'RepeatedDeleteAddressRequest',
    as ArrayRef[DeleteAddressRequest()];

coerce 'RepeatedDeleteAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteAddressRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteAddressRequest',
    as HashRef[DeleteAddressRequest()];

declare 'DeleteAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteAutoscalerRequest'];

coerce 'DeleteAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteAutoscalerRequest'->new($_) };

declare 'RepeatedDeleteAutoscalerRequest',
    as ArrayRef[DeleteAutoscalerRequest()];

coerce 'RepeatedDeleteAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteAutoscalerRequest',
    as HashRef[DeleteAutoscalerRequest()];

declare 'DeleteBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteBackendBucketRequest'];

coerce 'DeleteBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteBackendBucketRequest'->new($_) };

declare 'RepeatedDeleteBackendBucketRequest',
    as ArrayRef[DeleteBackendBucketRequest()];

coerce 'RepeatedDeleteBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteBackendBucketRequest',
    as HashRef[DeleteBackendBucketRequest()];

declare 'DeleteBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteBackendServiceRequest'];

coerce 'DeleteBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteBackendServiceRequest'->new($_) };

declare 'RepeatedDeleteBackendServiceRequest',
    as ArrayRef[DeleteBackendServiceRequest()];

coerce 'RepeatedDeleteBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteBackendServiceRequest',
    as HashRef[DeleteBackendServiceRequest()];

declare 'DeleteCrossSiteNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteCrossSiteNetworkRequest'];

coerce 'DeleteCrossSiteNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteCrossSiteNetworkRequest'->new($_) };

declare 'RepeatedDeleteCrossSiteNetworkRequest',
    as ArrayRef[DeleteCrossSiteNetworkRequest()];

coerce 'RepeatedDeleteCrossSiteNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteCrossSiteNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteCrossSiteNetworkRequest',
    as HashRef[DeleteCrossSiteNetworkRequest()];

declare 'DeleteDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteDiskRequest'];

coerce 'DeleteDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteDiskRequest'->new($_) };

declare 'RepeatedDeleteDiskRequest',
    as ArrayRef[DeleteDiskRequest()];

coerce 'RepeatedDeleteDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteDiskRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteDiskRequest',
    as HashRef[DeleteDiskRequest()];

declare 'DeleteExternalVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteExternalVpnGatewayRequest'];

coerce 'DeleteExternalVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteExternalVpnGatewayRequest'->new($_) };

declare 'RepeatedDeleteExternalVpnGatewayRequest',
    as ArrayRef[DeleteExternalVpnGatewayRequest()];

coerce 'RepeatedDeleteExternalVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteExternalVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteExternalVpnGatewayRequest',
    as HashRef[DeleteExternalVpnGatewayRequest()];

declare 'DeleteFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteFirewallPolicyRequest'];

coerce 'DeleteFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteFirewallPolicyRequest'->new($_) };

declare 'RepeatedDeleteFirewallPolicyRequest',
    as ArrayRef[DeleteFirewallPolicyRequest()];

coerce 'RepeatedDeleteFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteFirewallPolicyRequest',
    as HashRef[DeleteFirewallPolicyRequest()];

declare 'DeleteFirewallRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteFirewallRequest'];

coerce 'DeleteFirewallRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteFirewallRequest'->new($_) };

declare 'RepeatedDeleteFirewallRequest',
    as ArrayRef[DeleteFirewallRequest()];

coerce 'RepeatedDeleteFirewallRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteFirewallRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteFirewallRequest',
    as HashRef[DeleteFirewallRequest()];

declare 'DeleteForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteForwardingRuleRequest'];

coerce 'DeleteForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteForwardingRuleRequest'->new($_) };

declare 'RepeatedDeleteForwardingRuleRequest',
    as ArrayRef[DeleteForwardingRuleRequest()];

coerce 'RepeatedDeleteForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteForwardingRuleRequest',
    as HashRef[DeleteForwardingRuleRequest()];

declare 'DeleteFutureReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteFutureReservationRequest'];

coerce 'DeleteFutureReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteFutureReservationRequest'->new($_) };

declare 'RepeatedDeleteFutureReservationRequest',
    as ArrayRef[DeleteFutureReservationRequest()];

coerce 'RepeatedDeleteFutureReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteFutureReservationRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteFutureReservationRequest',
    as HashRef[DeleteFutureReservationRequest()];

declare 'DeleteGlobalAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalAddressRequest'];

coerce 'DeleteGlobalAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalAddressRequest'->new($_) };

declare 'RepeatedDeleteGlobalAddressRequest',
    as ArrayRef[DeleteGlobalAddressRequest()];

coerce 'RepeatedDeleteGlobalAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalAddressRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalAddressRequest',
    as HashRef[DeleteGlobalAddressRequest()];

declare 'DeleteGlobalForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalForwardingRuleRequest'];

coerce 'DeleteGlobalForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalForwardingRuleRequest'->new($_) };

declare 'RepeatedDeleteGlobalForwardingRuleRequest',
    as ArrayRef[DeleteGlobalForwardingRuleRequest()];

coerce 'RepeatedDeleteGlobalForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalForwardingRuleRequest',
    as HashRef[DeleteGlobalForwardingRuleRequest()];

declare 'DeleteGlobalNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalNetworkEndpointGroupRequest'];

coerce 'DeleteGlobalNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedDeleteGlobalNetworkEndpointGroupRequest',
    as ArrayRef[DeleteGlobalNetworkEndpointGroupRequest()];

coerce 'RepeatedDeleteGlobalNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalNetworkEndpointGroupRequest',
    as HashRef[DeleteGlobalNetworkEndpointGroupRequest()];

declare 'DeleteGlobalOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalOperationRequest'];

coerce 'DeleteGlobalOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOperationRequest'->new($_) };

declare 'RepeatedDeleteGlobalOperationRequest',
    as ArrayRef[DeleteGlobalOperationRequest()];

coerce 'RepeatedDeleteGlobalOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOperationRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalOperationRequest',
    as HashRef[DeleteGlobalOperationRequest()];

declare 'DeleteGlobalOperationResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalOperationResponse'];

coerce 'DeleteGlobalOperationResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOperationResponse'->new($_) };

declare 'RepeatedDeleteGlobalOperationResponse',
    as ArrayRef[DeleteGlobalOperationResponse()];

coerce 'RepeatedDeleteGlobalOperationResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOperationResponse'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalOperationResponse',
    as HashRef[DeleteGlobalOperationResponse()];

declare 'DeleteGlobalOrganizationOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalOrganizationOperationRequest'];

coerce 'DeleteGlobalOrganizationOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOrganizationOperationRequest'->new($_) };

declare 'RepeatedDeleteGlobalOrganizationOperationRequest',
    as ArrayRef[DeleteGlobalOrganizationOperationRequest()];

coerce 'RepeatedDeleteGlobalOrganizationOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOrganizationOperationRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalOrganizationOperationRequest',
    as HashRef[DeleteGlobalOrganizationOperationRequest()];

declare 'DeleteGlobalOrganizationOperationResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalOrganizationOperationResponse'];

coerce 'DeleteGlobalOrganizationOperationResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOrganizationOperationResponse'->new($_) };

declare 'RepeatedDeleteGlobalOrganizationOperationResponse',
    as ArrayRef[DeleteGlobalOrganizationOperationResponse()];

coerce 'RepeatedDeleteGlobalOrganizationOperationResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalOrganizationOperationResponse'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalOrganizationOperationResponse',
    as HashRef[DeleteGlobalOrganizationOperationResponse()];

declare 'DeleteGlobalPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalPublicDelegatedPrefixeRequest'];

coerce 'DeleteGlobalPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedDeleteGlobalPublicDelegatedPrefixeRequest',
    as ArrayRef[DeleteGlobalPublicDelegatedPrefixeRequest()];

coerce 'RepeatedDeleteGlobalPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalPublicDelegatedPrefixeRequest',
    as HashRef[DeleteGlobalPublicDelegatedPrefixeRequest()];

declare 'DeleteGlobalVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteGlobalVmExtensionPolicyRequest'];

coerce 'DeleteGlobalVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedDeleteGlobalVmExtensionPolicyRequest',
    as ArrayRef[DeleteGlobalVmExtensionPolicyRequest()];

coerce 'RepeatedDeleteGlobalVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteGlobalVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteGlobalVmExtensionPolicyRequest',
    as HashRef[DeleteGlobalVmExtensionPolicyRequest()];

declare 'DeleteHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteHealthCheckRequest'];

coerce 'DeleteHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteHealthCheckRequest'->new($_) };

declare 'RepeatedDeleteHealthCheckRequest',
    as ArrayRef[DeleteHealthCheckRequest()];

coerce 'RepeatedDeleteHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteHealthCheckRequest',
    as HashRef[DeleteHealthCheckRequest()];

declare 'DeleteImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteImageRequest'];

coerce 'DeleteImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteImageRequest'->new($_) };

declare 'RepeatedDeleteImageRequest',
    as ArrayRef[DeleteImageRequest()];

coerce 'RepeatedDeleteImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteImageRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteImageRequest',
    as HashRef[DeleteImageRequest()];

declare 'DeleteInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupManagerRequest'];

coerce 'DeleteInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedDeleteInstanceGroupManagerRequest',
    as ArrayRef[DeleteInstanceGroupManagerRequest()];

coerce 'RepeatedDeleteInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstanceGroupManagerRequest',
    as HashRef[DeleteInstanceGroupManagerRequest()];

declare 'DeleteInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupManagerResizeRequestRequest'];

coerce 'DeleteInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedDeleteInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[DeleteInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedDeleteInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstanceGroupManagerResizeRequestRequest',
    as HashRef[DeleteInstanceGroupManagerResizeRequestRequest()];

declare 'DeleteInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupRequest'];

coerce 'DeleteInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupRequest'->new($_) };

declare 'RepeatedDeleteInstanceGroupRequest',
    as ArrayRef[DeleteInstanceGroupRequest()];

coerce 'RepeatedDeleteInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstanceGroupRequest',
    as HashRef[DeleteInstanceGroupRequest()];

declare 'DeleteInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstanceRequest'];

coerce 'DeleteInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceRequest'->new($_) };

declare 'RepeatedDeleteInstanceRequest',
    as ArrayRef[DeleteInstanceRequest()];

coerce 'RepeatedDeleteInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstanceRequest',
    as HashRef[DeleteInstanceRequest()];

declare 'DeleteInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstanceTemplateRequest'];

coerce 'DeleteInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceTemplateRequest'->new($_) };

declare 'RepeatedDeleteInstanceTemplateRequest',
    as ArrayRef[DeleteInstanceTemplateRequest()];

coerce 'RepeatedDeleteInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstanceTemplateRequest',
    as HashRef[DeleteInstanceTemplateRequest()];

declare 'DeleteInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstancesInstanceGroupManagerRequest'];

coerce 'DeleteInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedDeleteInstancesInstanceGroupManagerRequest',
    as ArrayRef[DeleteInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedDeleteInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstancesInstanceGroupManagerRequest',
    as HashRef[DeleteInstancesInstanceGroupManagerRequest()];

declare 'DeleteInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstancesRegionInstanceGroupManagerRequest'];

coerce 'DeleteInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedDeleteInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[DeleteInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedDeleteInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstancesRegionInstanceGroupManagerRequest',
    as HashRef[DeleteInstancesRegionInstanceGroupManagerRequest()];

declare 'DeleteInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstantSnapshotGroupRequest'];

coerce 'DeleteInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedDeleteInstantSnapshotGroupRequest',
    as ArrayRef[DeleteInstantSnapshotGroupRequest()];

coerce 'RepeatedDeleteInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstantSnapshotGroupRequest',
    as HashRef[DeleteInstantSnapshotGroupRequest()];

declare 'DeleteInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInstantSnapshotRequest'];

coerce 'DeleteInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInstantSnapshotRequest'->new($_) };

declare 'RepeatedDeleteInstantSnapshotRequest',
    as ArrayRef[DeleteInstantSnapshotRequest()];

coerce 'RepeatedDeleteInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInstantSnapshotRequest',
    as HashRef[DeleteInstantSnapshotRequest()];

declare 'DeleteInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInterconnectAttachmentGroupRequest'];

coerce 'DeleteInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedDeleteInterconnectAttachmentGroupRequest',
    as ArrayRef[DeleteInterconnectAttachmentGroupRequest()];

coerce 'RepeatedDeleteInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInterconnectAttachmentGroupRequest',
    as HashRef[DeleteInterconnectAttachmentGroupRequest()];

declare 'DeleteInterconnectAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInterconnectAttachmentRequest'];

coerce 'DeleteInterconnectAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectAttachmentRequest'->new($_) };

declare 'RepeatedDeleteInterconnectAttachmentRequest',
    as ArrayRef[DeleteInterconnectAttachmentRequest()];

coerce 'RepeatedDeleteInterconnectAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInterconnectAttachmentRequest',
    as HashRef[DeleteInterconnectAttachmentRequest()];

declare 'DeleteInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInterconnectGroupRequest'];

coerce 'DeleteInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectGroupRequest'->new($_) };

declare 'RepeatedDeleteInterconnectGroupRequest',
    as ArrayRef[DeleteInterconnectGroupRequest()];

coerce 'RepeatedDeleteInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInterconnectGroupRequest',
    as HashRef[DeleteInterconnectGroupRequest()];

declare 'DeleteInterconnectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteInterconnectRequest'];

coerce 'DeleteInterconnectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectRequest'->new($_) };

declare 'RepeatedDeleteInterconnectRequest',
    as ArrayRef[DeleteInterconnectRequest()];

coerce 'RepeatedDeleteInterconnectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteInterconnectRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteInterconnectRequest',
    as HashRef[DeleteInterconnectRequest()];

declare 'DeleteLicenseRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteLicenseRequest'];

coerce 'DeleteLicenseRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteLicenseRequest'->new($_) };

declare 'RepeatedDeleteLicenseRequest',
    as ArrayRef[DeleteLicenseRequest()];

coerce 'RepeatedDeleteLicenseRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteLicenseRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteLicenseRequest',
    as HashRef[DeleteLicenseRequest()];

declare 'DeleteMachineImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteMachineImageRequest'];

coerce 'DeleteMachineImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteMachineImageRequest'->new($_) };

declare 'RepeatedDeleteMachineImageRequest',
    as ArrayRef[DeleteMachineImageRequest()];

coerce 'RepeatedDeleteMachineImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteMachineImageRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteMachineImageRequest',
    as HashRef[DeleteMachineImageRequest()];

declare 'DeleteNamedSetRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNamedSetRouterRequest'];

coerce 'DeleteNamedSetRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNamedSetRouterRequest'->new($_) };

declare 'RepeatedDeleteNamedSetRouterRequest',
    as ArrayRef[DeleteNamedSetRouterRequest()];

coerce 'RepeatedDeleteNamedSetRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNamedSetRouterRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNamedSetRouterRequest',
    as HashRef[DeleteNamedSetRouterRequest()];

declare 'DeleteNetworkAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNetworkAttachmentRequest'];

coerce 'DeleteNetworkAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkAttachmentRequest'->new($_) };

declare 'RepeatedDeleteNetworkAttachmentRequest',
    as ArrayRef[DeleteNetworkAttachmentRequest()];

coerce 'RepeatedDeleteNetworkAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNetworkAttachmentRequest',
    as HashRef[DeleteNetworkAttachmentRequest()];

declare 'DeleteNetworkEdgeSecurityServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNetworkEdgeSecurityServiceRequest'];

coerce 'DeleteNetworkEdgeSecurityServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkEdgeSecurityServiceRequest'->new($_) };

declare 'RepeatedDeleteNetworkEdgeSecurityServiceRequest',
    as ArrayRef[DeleteNetworkEdgeSecurityServiceRequest()];

coerce 'RepeatedDeleteNetworkEdgeSecurityServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkEdgeSecurityServiceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNetworkEdgeSecurityServiceRequest',
    as HashRef[DeleteNetworkEdgeSecurityServiceRequest()];

declare 'DeleteNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNetworkEndpointGroupRequest'];

coerce 'DeleteNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedDeleteNetworkEndpointGroupRequest',
    as ArrayRef[DeleteNetworkEndpointGroupRequest()];

coerce 'RepeatedDeleteNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNetworkEndpointGroupRequest',
    as HashRef[DeleteNetworkEndpointGroupRequest()];

declare 'DeleteNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNetworkFirewallPolicyRequest'];

coerce 'DeleteNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedDeleteNetworkFirewallPolicyRequest',
    as ArrayRef[DeleteNetworkFirewallPolicyRequest()];

coerce 'RepeatedDeleteNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNetworkFirewallPolicyRequest',
    as HashRef[DeleteNetworkFirewallPolicyRequest()];

declare 'DeleteNetworkInterfaceInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNetworkInterfaceInstanceRequest'];

coerce 'DeleteNetworkInterfaceInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkInterfaceInstanceRequest'->new($_) };

declare 'RepeatedDeleteNetworkInterfaceInstanceRequest',
    as ArrayRef[DeleteNetworkInterfaceInstanceRequest()];

coerce 'RepeatedDeleteNetworkInterfaceInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkInterfaceInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNetworkInterfaceInstanceRequest',
    as HashRef[DeleteNetworkInterfaceInstanceRequest()];

declare 'DeleteNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNetworkRequest'];

coerce 'DeleteNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkRequest'->new($_) };

declare 'RepeatedDeleteNetworkRequest',
    as ArrayRef[DeleteNetworkRequest()];

coerce 'RepeatedDeleteNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNetworkRequest',
    as HashRef[DeleteNetworkRequest()];

declare 'DeleteNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNodeGroupRequest'];

coerce 'DeleteNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNodeGroupRequest'->new($_) };

declare 'RepeatedDeleteNodeGroupRequest',
    as ArrayRef[DeleteNodeGroupRequest()];

coerce 'RepeatedDeleteNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNodeGroupRequest',
    as HashRef[DeleteNodeGroupRequest()];

declare 'DeleteNodeTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNodeTemplateRequest'];

coerce 'DeleteNodeTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNodeTemplateRequest'->new($_) };

declare 'RepeatedDeleteNodeTemplateRequest',
    as ArrayRef[DeleteNodeTemplateRequest()];

coerce 'RepeatedDeleteNodeTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNodeTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNodeTemplateRequest',
    as HashRef[DeleteNodeTemplateRequest()];

declare 'DeleteNodesNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteNodesNodeGroupRequest'];

coerce 'DeleteNodesNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteNodesNodeGroupRequest'->new($_) };

declare 'RepeatedDeleteNodesNodeGroupRequest',
    as ArrayRef[DeleteNodesNodeGroupRequest()];

coerce 'RepeatedDeleteNodesNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteNodesNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteNodesNodeGroupRequest',
    as HashRef[DeleteNodesNodeGroupRequest()];

declare 'DeleteOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteOrganizationSecurityPolicyRequest'];

coerce 'DeleteOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedDeleteOrganizationSecurityPolicyRequest',
    as ArrayRef[DeleteOrganizationSecurityPolicyRequest()];

coerce 'RepeatedDeleteOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteOrganizationSecurityPolicyRequest',
    as HashRef[DeleteOrganizationSecurityPolicyRequest()];

declare 'DeletePacketMirroringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeletePacketMirroringRequest'];

coerce 'DeletePacketMirroringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeletePacketMirroringRequest'->new($_) };

declare 'RepeatedDeletePacketMirroringRequest',
    as ArrayRef[DeletePacketMirroringRequest()];

coerce 'RepeatedDeletePacketMirroringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeletePacketMirroringRequest'->new($_) } @$_ ] };

declare 'MapStringDeletePacketMirroringRequest',
    as HashRef[DeletePacketMirroringRequest()];

declare 'DeletePerInstanceConfigsInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeletePerInstanceConfigsInstanceGroupManagerRequest'];

coerce 'DeletePerInstanceConfigsInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeletePerInstanceConfigsInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedDeletePerInstanceConfigsInstanceGroupManagerRequest',
    as ArrayRef[DeletePerInstanceConfigsInstanceGroupManagerRequest()];

coerce 'RepeatedDeletePerInstanceConfigsInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeletePerInstanceConfigsInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringDeletePerInstanceConfigsInstanceGroupManagerRequest',
    as HashRef[DeletePerInstanceConfigsInstanceGroupManagerRequest()];

declare 'DeletePerInstanceConfigsRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeletePerInstanceConfigsRegionInstanceGroupManagerRequest'];

coerce 'DeletePerInstanceConfigsRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeletePerInstanceConfigsRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedDeletePerInstanceConfigsRegionInstanceGroupManagerRequest',
    as ArrayRef[DeletePerInstanceConfigsRegionInstanceGroupManagerRequest()];

coerce 'RepeatedDeletePerInstanceConfigsRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeletePerInstanceConfigsRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringDeletePerInstanceConfigsRegionInstanceGroupManagerRequest',
    as HashRef[DeletePerInstanceConfigsRegionInstanceGroupManagerRequest()];

declare 'DeletePublicAdvertisedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeletePublicAdvertisedPrefixeRequest'];

coerce 'DeletePublicAdvertisedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeletePublicAdvertisedPrefixeRequest'->new($_) };

declare 'RepeatedDeletePublicAdvertisedPrefixeRequest',
    as ArrayRef[DeletePublicAdvertisedPrefixeRequest()];

coerce 'RepeatedDeletePublicAdvertisedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeletePublicAdvertisedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringDeletePublicAdvertisedPrefixeRequest',
    as HashRef[DeletePublicAdvertisedPrefixeRequest()];

declare 'DeletePublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeletePublicDelegatedPrefixeRequest'];

coerce 'DeletePublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeletePublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedDeletePublicDelegatedPrefixeRequest',
    as ArrayRef[DeletePublicDelegatedPrefixeRequest()];

coerce 'RepeatedDeletePublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeletePublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringDeletePublicDelegatedPrefixeRequest',
    as HashRef[DeletePublicDelegatedPrefixeRequest()];

declare 'DeleteRegionAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionAutoscalerRequest'];

coerce 'DeleteRegionAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionAutoscalerRequest'->new($_) };

declare 'RepeatedDeleteRegionAutoscalerRequest',
    as ArrayRef[DeleteRegionAutoscalerRequest()];

coerce 'RepeatedDeleteRegionAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionAutoscalerRequest',
    as HashRef[DeleteRegionAutoscalerRequest()];

declare 'DeleteRegionBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionBackendBucketRequest'];

coerce 'DeleteRegionBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionBackendBucketRequest'->new($_) };

declare 'RepeatedDeleteRegionBackendBucketRequest',
    as ArrayRef[DeleteRegionBackendBucketRequest()];

coerce 'RepeatedDeleteRegionBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionBackendBucketRequest',
    as HashRef[DeleteRegionBackendBucketRequest()];

declare 'DeleteRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionBackendServiceRequest'];

coerce 'DeleteRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionBackendServiceRequest'->new($_) };

declare 'RepeatedDeleteRegionBackendServiceRequest',
    as ArrayRef[DeleteRegionBackendServiceRequest()];

coerce 'RepeatedDeleteRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionBackendServiceRequest',
    as HashRef[DeleteRegionBackendServiceRequest()];

declare 'DeleteRegionCompositeHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionCompositeHealthCheckRequest'];

coerce 'DeleteRegionCompositeHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionCompositeHealthCheckRequest'->new($_) };

declare 'RepeatedDeleteRegionCompositeHealthCheckRequest',
    as ArrayRef[DeleteRegionCompositeHealthCheckRequest()];

coerce 'RepeatedDeleteRegionCompositeHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionCompositeHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionCompositeHealthCheckRequest',
    as HashRef[DeleteRegionCompositeHealthCheckRequest()];

declare 'DeleteRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionDiskRequest'];

coerce 'DeleteRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionDiskRequest'->new($_) };

declare 'RepeatedDeleteRegionDiskRequest',
    as ArrayRef[DeleteRegionDiskRequest()];

coerce 'RepeatedDeleteRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionDiskRequest',
    as HashRef[DeleteRegionDiskRequest()];

declare 'DeleteRegionHealthAggregationPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionHealthAggregationPolicyRequest'];

coerce 'DeleteRegionHealthAggregationPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthAggregationPolicyRequest'->new($_) };

declare 'RepeatedDeleteRegionHealthAggregationPolicyRequest',
    as ArrayRef[DeleteRegionHealthAggregationPolicyRequest()];

coerce 'RepeatedDeleteRegionHealthAggregationPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthAggregationPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionHealthAggregationPolicyRequest',
    as HashRef[DeleteRegionHealthAggregationPolicyRequest()];

declare 'DeleteRegionHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionHealthCheckRequest'];

coerce 'DeleteRegionHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthCheckRequest'->new($_) };

declare 'RepeatedDeleteRegionHealthCheckRequest',
    as ArrayRef[DeleteRegionHealthCheckRequest()];

coerce 'RepeatedDeleteRegionHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionHealthCheckRequest',
    as HashRef[DeleteRegionHealthCheckRequest()];

declare 'DeleteRegionHealthCheckServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionHealthCheckServiceRequest'];

coerce 'DeleteRegionHealthCheckServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthCheckServiceRequest'->new($_) };

declare 'RepeatedDeleteRegionHealthCheckServiceRequest',
    as ArrayRef[DeleteRegionHealthCheckServiceRequest()];

coerce 'RepeatedDeleteRegionHealthCheckServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthCheckServiceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionHealthCheckServiceRequest',
    as HashRef[DeleteRegionHealthCheckServiceRequest()];

declare 'DeleteRegionHealthSourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionHealthSourceRequest'];

coerce 'DeleteRegionHealthSourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthSourceRequest'->new($_) };

declare 'RepeatedDeleteRegionHealthSourceRequest',
    as ArrayRef[DeleteRegionHealthSourceRequest()];

coerce 'RepeatedDeleteRegionHealthSourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionHealthSourceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionHealthSourceRequest',
    as HashRef[DeleteRegionHealthSourceRequest()];

declare 'DeleteRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceGroupManagerRequest'];

coerce 'DeleteRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedDeleteRegionInstanceGroupManagerRequest',
    as ArrayRef[DeleteRegionInstanceGroupManagerRequest()];

coerce 'RepeatedDeleteRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionInstanceGroupManagerRequest',
    as HashRef[DeleteRegionInstanceGroupManagerRequest()];

declare 'DeleteRegionInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceGroupManagerResizeRequestRequest'];

coerce 'DeleteRegionInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedDeleteRegionInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[DeleteRegionInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedDeleteRegionInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionInstanceGroupManagerResizeRequestRequest',
    as HashRef[DeleteRegionInstanceGroupManagerResizeRequestRequest()];

declare 'DeleteRegionInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceTemplateRequest'];

coerce 'DeleteRegionInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceTemplateRequest'->new($_) };

declare 'RepeatedDeleteRegionInstanceTemplateRequest',
    as ArrayRef[DeleteRegionInstanceTemplateRequest()];

coerce 'RepeatedDeleteRegionInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionInstanceTemplateRequest',
    as HashRef[DeleteRegionInstanceTemplateRequest()];

declare 'DeleteRegionInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionInstantSnapshotGroupRequest'];

coerce 'DeleteRegionInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedDeleteRegionInstantSnapshotGroupRequest',
    as ArrayRef[DeleteRegionInstantSnapshotGroupRequest()];

coerce 'RepeatedDeleteRegionInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionInstantSnapshotGroupRequest',
    as HashRef[DeleteRegionInstantSnapshotGroupRequest()];

declare 'DeleteRegionInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionInstantSnapshotRequest'];

coerce 'DeleteRegionInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstantSnapshotRequest'->new($_) };

declare 'RepeatedDeleteRegionInstantSnapshotRequest',
    as ArrayRef[DeleteRegionInstantSnapshotRequest()];

coerce 'RepeatedDeleteRegionInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionInstantSnapshotRequest',
    as HashRef[DeleteRegionInstantSnapshotRequest()];

declare 'DeleteRegionNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionNetworkEndpointGroupRequest'];

coerce 'DeleteRegionNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedDeleteRegionNetworkEndpointGroupRequest',
    as ArrayRef[DeleteRegionNetworkEndpointGroupRequest()];

coerce 'RepeatedDeleteRegionNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionNetworkEndpointGroupRequest',
    as HashRef[DeleteRegionNetworkEndpointGroupRequest()];

declare 'DeleteRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionNetworkFirewallPolicyRequest'];

coerce 'DeleteRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedDeleteRegionNetworkFirewallPolicyRequest',
    as ArrayRef[DeleteRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedDeleteRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionNetworkFirewallPolicyRequest',
    as HashRef[DeleteRegionNetworkFirewallPolicyRequest()];

declare 'DeleteRegionNotificationEndpointRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionNotificationEndpointRequest'];

coerce 'DeleteRegionNotificationEndpointRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionNotificationEndpointRequest'->new($_) };

declare 'RepeatedDeleteRegionNotificationEndpointRequest',
    as ArrayRef[DeleteRegionNotificationEndpointRequest()];

coerce 'RepeatedDeleteRegionNotificationEndpointRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionNotificationEndpointRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionNotificationEndpointRequest',
    as HashRef[DeleteRegionNotificationEndpointRequest()];

declare 'DeleteRegionOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionOperationRequest'];

coerce 'DeleteRegionOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionOperationRequest'->new($_) };

declare 'RepeatedDeleteRegionOperationRequest',
    as ArrayRef[DeleteRegionOperationRequest()];

coerce 'RepeatedDeleteRegionOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionOperationRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionOperationRequest',
    as HashRef[DeleteRegionOperationRequest()];

declare 'DeleteRegionOperationResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionOperationResponse'];

coerce 'DeleteRegionOperationResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionOperationResponse'->new($_) };

declare 'RepeatedDeleteRegionOperationResponse',
    as ArrayRef[DeleteRegionOperationResponse()];

coerce 'RepeatedDeleteRegionOperationResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionOperationResponse'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionOperationResponse',
    as HashRef[DeleteRegionOperationResponse()];

declare 'DeleteRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionSecurityPolicyRequest'];

coerce 'DeleteRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedDeleteRegionSecurityPolicyRequest',
    as ArrayRef[DeleteRegionSecurityPolicyRequest()];

coerce 'RepeatedDeleteRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionSecurityPolicyRequest',
    as HashRef[DeleteRegionSecurityPolicyRequest()];

declare 'DeleteRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionSnapshotRequest'];

coerce 'DeleteRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSnapshotRequest'->new($_) };

declare 'RepeatedDeleteRegionSnapshotRequest',
    as ArrayRef[DeleteRegionSnapshotRequest()];

coerce 'RepeatedDeleteRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionSnapshotRequest',
    as HashRef[DeleteRegionSnapshotRequest()];

declare 'DeleteRegionSslCertificateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionSslCertificateRequest'];

coerce 'DeleteRegionSslCertificateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSslCertificateRequest'->new($_) };

declare 'RepeatedDeleteRegionSslCertificateRequest',
    as ArrayRef[DeleteRegionSslCertificateRequest()];

coerce 'RepeatedDeleteRegionSslCertificateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSslCertificateRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionSslCertificateRequest',
    as HashRef[DeleteRegionSslCertificateRequest()];

declare 'DeleteRegionSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionSslPolicyRequest'];

coerce 'DeleteRegionSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSslPolicyRequest'->new($_) };

declare 'RepeatedDeleteRegionSslPolicyRequest',
    as ArrayRef[DeleteRegionSslPolicyRequest()];

coerce 'RepeatedDeleteRegionSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionSslPolicyRequest',
    as HashRef[DeleteRegionSslPolicyRequest()];

declare 'DeleteRegionTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionTargetHttpProxyRequest'];

coerce 'DeleteRegionTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionTargetHttpProxyRequest'->new($_) };

declare 'RepeatedDeleteRegionTargetHttpProxyRequest',
    as ArrayRef[DeleteRegionTargetHttpProxyRequest()];

coerce 'RepeatedDeleteRegionTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionTargetHttpProxyRequest',
    as HashRef[DeleteRegionTargetHttpProxyRequest()];

declare 'DeleteRegionTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionTargetHttpsProxyRequest'];

coerce 'DeleteRegionTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedDeleteRegionTargetHttpsProxyRequest',
    as ArrayRef[DeleteRegionTargetHttpsProxyRequest()];

coerce 'RepeatedDeleteRegionTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionTargetHttpsProxyRequest',
    as HashRef[DeleteRegionTargetHttpsProxyRequest()];

declare 'DeleteRegionTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionTargetTcpProxyRequest'];

coerce 'DeleteRegionTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionTargetTcpProxyRequest'->new($_) };

declare 'RepeatedDeleteRegionTargetTcpProxyRequest',
    as ArrayRef[DeleteRegionTargetTcpProxyRequest()];

coerce 'RepeatedDeleteRegionTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionTargetTcpProxyRequest',
    as HashRef[DeleteRegionTargetTcpProxyRequest()];

declare 'DeleteRegionUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRegionUrlMapRequest'];

coerce 'DeleteRegionUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRegionUrlMapRequest'->new($_) };

declare 'RepeatedDeleteRegionUrlMapRequest',
    as ArrayRef[DeleteRegionUrlMapRequest()];

coerce 'RepeatedDeleteRegionUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRegionUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRegionUrlMapRequest',
    as HashRef[DeleteRegionUrlMapRequest()];

declare 'DeleteReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteReservationRequest'];

coerce 'DeleteReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteReservationRequest'->new($_) };

declare 'RepeatedDeleteReservationRequest',
    as ArrayRef[DeleteReservationRequest()];

coerce 'RepeatedDeleteReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteReservationRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteReservationRequest',
    as HashRef[DeleteReservationRequest()];

declare 'DeleteResourcePolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteResourcePolicyRequest'];

coerce 'DeleteResourcePolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteResourcePolicyRequest'->new($_) };

declare 'RepeatedDeleteResourcePolicyRequest',
    as ArrayRef[DeleteResourcePolicyRequest()];

coerce 'RepeatedDeleteResourcePolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteResourcePolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteResourcePolicyRequest',
    as HashRef[DeleteResourcePolicyRequest()];

declare 'DeleteRolloutPlanRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRolloutPlanRequest'];

coerce 'DeleteRolloutPlanRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRolloutPlanRequest'->new($_) };

declare 'RepeatedDeleteRolloutPlanRequest',
    as ArrayRef[DeleteRolloutPlanRequest()];

coerce 'RepeatedDeleteRolloutPlanRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRolloutPlanRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRolloutPlanRequest',
    as HashRef[DeleteRolloutPlanRequest()];

declare 'DeleteRolloutRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRolloutRequest'];

coerce 'DeleteRolloutRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRolloutRequest'->new($_) };

declare 'RepeatedDeleteRolloutRequest',
    as ArrayRef[DeleteRolloutRequest()];

coerce 'RepeatedDeleteRolloutRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRolloutRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRolloutRequest',
    as HashRef[DeleteRolloutRequest()];

declare 'DeleteRoutePolicyRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRoutePolicyRouterRequest'];

coerce 'DeleteRoutePolicyRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRoutePolicyRouterRequest'->new($_) };

declare 'RepeatedDeleteRoutePolicyRouterRequest',
    as ArrayRef[DeleteRoutePolicyRouterRequest()];

coerce 'RepeatedDeleteRoutePolicyRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRoutePolicyRouterRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRoutePolicyRouterRequest',
    as HashRef[DeleteRoutePolicyRouterRequest()];

declare 'DeleteRouteRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRouteRequest'];

coerce 'DeleteRouteRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRouteRequest'->new($_) };

declare 'RepeatedDeleteRouteRequest',
    as ArrayRef[DeleteRouteRequest()];

coerce 'RepeatedDeleteRouteRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRouteRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRouteRequest',
    as HashRef[DeleteRouteRequest()];

declare 'DeleteRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteRouterRequest'];

coerce 'DeleteRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteRouterRequest'->new($_) };

declare 'RepeatedDeleteRouterRequest',
    as ArrayRef[DeleteRouterRequest()];

coerce 'RepeatedDeleteRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteRouterRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteRouterRequest',
    as HashRef[DeleteRouterRequest()];

declare 'DeleteSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteSecurityPolicyRequest'];

coerce 'DeleteSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteSecurityPolicyRequest'->new($_) };

declare 'RepeatedDeleteSecurityPolicyRequest',
    as ArrayRef[DeleteSecurityPolicyRequest()];

coerce 'RepeatedDeleteSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteSecurityPolicyRequest',
    as HashRef[DeleteSecurityPolicyRequest()];

declare 'DeleteServiceAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteServiceAttachmentRequest'];

coerce 'DeleteServiceAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteServiceAttachmentRequest'->new($_) };

declare 'RepeatedDeleteServiceAttachmentRequest',
    as ArrayRef[DeleteServiceAttachmentRequest()];

coerce 'RepeatedDeleteServiceAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteServiceAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteServiceAttachmentRequest',
    as HashRef[DeleteServiceAttachmentRequest()];

declare 'DeleteSignedUrlKeyBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteSignedUrlKeyBackendBucketRequest'];

coerce 'DeleteSignedUrlKeyBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteSignedUrlKeyBackendBucketRequest'->new($_) };

declare 'RepeatedDeleteSignedUrlKeyBackendBucketRequest',
    as ArrayRef[DeleteSignedUrlKeyBackendBucketRequest()];

coerce 'RepeatedDeleteSignedUrlKeyBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteSignedUrlKeyBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteSignedUrlKeyBackendBucketRequest',
    as HashRef[DeleteSignedUrlKeyBackendBucketRequest()];

declare 'DeleteSignedUrlKeyBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteSignedUrlKeyBackendServiceRequest'];

coerce 'DeleteSignedUrlKeyBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteSignedUrlKeyBackendServiceRequest'->new($_) };

declare 'RepeatedDeleteSignedUrlKeyBackendServiceRequest',
    as ArrayRef[DeleteSignedUrlKeyBackendServiceRequest()];

coerce 'RepeatedDeleteSignedUrlKeyBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteSignedUrlKeyBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteSignedUrlKeyBackendServiceRequest',
    as HashRef[DeleteSignedUrlKeyBackendServiceRequest()];

declare 'DeleteSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteSnapshotRequest'];

coerce 'DeleteSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteSnapshotRequest'->new($_) };

declare 'RepeatedDeleteSnapshotRequest',
    as ArrayRef[DeleteSnapshotRequest()];

coerce 'RepeatedDeleteSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteSnapshotRequest',
    as HashRef[DeleteSnapshotRequest()];

declare 'DeleteSslCertificateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteSslCertificateRequest'];

coerce 'DeleteSslCertificateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteSslCertificateRequest'->new($_) };

declare 'RepeatedDeleteSslCertificateRequest',
    as ArrayRef[DeleteSslCertificateRequest()];

coerce 'RepeatedDeleteSslCertificateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteSslCertificateRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteSslCertificateRequest',
    as HashRef[DeleteSslCertificateRequest()];

declare 'DeleteSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteSslPolicyRequest'];

coerce 'DeleteSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteSslPolicyRequest'->new($_) };

declare 'RepeatedDeleteSslPolicyRequest',
    as ArrayRef[DeleteSslPolicyRequest()];

coerce 'RepeatedDeleteSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteSslPolicyRequest',
    as HashRef[DeleteSslPolicyRequest()];

declare 'DeleteStoragePoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteStoragePoolRequest'];

coerce 'DeleteStoragePoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteStoragePoolRequest'->new($_) };

declare 'RepeatedDeleteStoragePoolRequest',
    as ArrayRef[DeleteStoragePoolRequest()];

coerce 'RepeatedDeleteStoragePoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteStoragePoolRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteStoragePoolRequest',
    as HashRef[DeleteStoragePoolRequest()];

declare 'DeleteSubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteSubnetworkRequest'];

coerce 'DeleteSubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteSubnetworkRequest'->new($_) };

declare 'RepeatedDeleteSubnetworkRequest',
    as ArrayRef[DeleteSubnetworkRequest()];

coerce 'RepeatedDeleteSubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteSubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteSubnetworkRequest',
    as HashRef[DeleteSubnetworkRequest()];

declare 'DeleteTargetGrpcProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetGrpcProxyRequest'];

coerce 'DeleteTargetGrpcProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetGrpcProxyRequest'->new($_) };

declare 'RepeatedDeleteTargetGrpcProxyRequest',
    as ArrayRef[DeleteTargetGrpcProxyRequest()];

coerce 'RepeatedDeleteTargetGrpcProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetGrpcProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetGrpcProxyRequest',
    as HashRef[DeleteTargetGrpcProxyRequest()];

declare 'DeleteTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetHttpProxyRequest'];

coerce 'DeleteTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetHttpProxyRequest'->new($_) };

declare 'RepeatedDeleteTargetHttpProxyRequest',
    as ArrayRef[DeleteTargetHttpProxyRequest()];

coerce 'RepeatedDeleteTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetHttpProxyRequest',
    as HashRef[DeleteTargetHttpProxyRequest()];

declare 'DeleteTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetHttpsProxyRequest'];

coerce 'DeleteTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedDeleteTargetHttpsProxyRequest',
    as ArrayRef[DeleteTargetHttpsProxyRequest()];

coerce 'RepeatedDeleteTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetHttpsProxyRequest',
    as HashRef[DeleteTargetHttpsProxyRequest()];

declare 'DeleteTargetInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetInstanceRequest'];

coerce 'DeleteTargetInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetInstanceRequest'->new($_) };

declare 'RepeatedDeleteTargetInstanceRequest',
    as ArrayRef[DeleteTargetInstanceRequest()];

coerce 'RepeatedDeleteTargetInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetInstanceRequest',
    as HashRef[DeleteTargetInstanceRequest()];

declare 'DeleteTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetPoolRequest'];

coerce 'DeleteTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetPoolRequest'->new($_) };

declare 'RepeatedDeleteTargetPoolRequest',
    as ArrayRef[DeleteTargetPoolRequest()];

coerce 'RepeatedDeleteTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetPoolRequest',
    as HashRef[DeleteTargetPoolRequest()];

declare 'DeleteTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetSslProxyRequest'];

coerce 'DeleteTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetSslProxyRequest'->new($_) };

declare 'RepeatedDeleteTargetSslProxyRequest',
    as ArrayRef[DeleteTargetSslProxyRequest()];

coerce 'RepeatedDeleteTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetSslProxyRequest',
    as HashRef[DeleteTargetSslProxyRequest()];

declare 'DeleteTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetTcpProxyRequest'];

coerce 'DeleteTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetTcpProxyRequest'->new($_) };

declare 'RepeatedDeleteTargetTcpProxyRequest',
    as ArrayRef[DeleteTargetTcpProxyRequest()];

coerce 'RepeatedDeleteTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetTcpProxyRequest',
    as HashRef[DeleteTargetTcpProxyRequest()];

declare 'DeleteTargetVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteTargetVpnGatewayRequest'];

coerce 'DeleteTargetVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteTargetVpnGatewayRequest'->new($_) };

declare 'RepeatedDeleteTargetVpnGatewayRequest',
    as ArrayRef[DeleteTargetVpnGatewayRequest()];

coerce 'RepeatedDeleteTargetVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteTargetVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteTargetVpnGatewayRequest',
    as HashRef[DeleteTargetVpnGatewayRequest()];

declare 'DeleteUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteUrlMapRequest'];

coerce 'DeleteUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteUrlMapRequest'->new($_) };

declare 'RepeatedDeleteUrlMapRequest',
    as ArrayRef[DeleteUrlMapRequest()];

coerce 'RepeatedDeleteUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteUrlMapRequest',
    as HashRef[DeleteUrlMapRequest()];

declare 'DeleteVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteVpnGatewayRequest'];

coerce 'DeleteVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteVpnGatewayRequest'->new($_) };

declare 'RepeatedDeleteVpnGatewayRequest',
    as ArrayRef[DeleteVpnGatewayRequest()];

coerce 'RepeatedDeleteVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteVpnGatewayRequest',
    as HashRef[DeleteVpnGatewayRequest()];

declare 'DeleteVpnTunnelRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteVpnTunnelRequest'];

coerce 'DeleteVpnTunnelRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteVpnTunnelRequest'->new($_) };

declare 'RepeatedDeleteVpnTunnelRequest',
    as ArrayRef[DeleteVpnTunnelRequest()];

coerce 'RepeatedDeleteVpnTunnelRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteVpnTunnelRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteVpnTunnelRequest',
    as HashRef[DeleteVpnTunnelRequest()];

declare 'DeleteWireGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteWireGroupRequest'];

coerce 'DeleteWireGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteWireGroupRequest'->new($_) };

declare 'RepeatedDeleteWireGroupRequest',
    as ArrayRef[DeleteWireGroupRequest()];

coerce 'RepeatedDeleteWireGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteWireGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteWireGroupRequest',
    as HashRef[DeleteWireGroupRequest()];

declare 'DeleteZoneOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteZoneOperationRequest'];

coerce 'DeleteZoneOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteZoneOperationRequest'->new($_) };

declare 'RepeatedDeleteZoneOperationRequest',
    as ArrayRef[DeleteZoneOperationRequest()];

coerce 'RepeatedDeleteZoneOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteZoneOperationRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteZoneOperationRequest',
    as HashRef[DeleteZoneOperationRequest()];

declare 'DeleteZoneOperationResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteZoneOperationResponse'];

coerce 'DeleteZoneOperationResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteZoneOperationResponse'->new($_) };

declare 'RepeatedDeleteZoneOperationResponse',
    as ArrayRef[DeleteZoneOperationResponse()];

coerce 'RepeatedDeleteZoneOperationResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteZoneOperationResponse'->new($_) } @$_ ] };

declare 'MapStringDeleteZoneOperationResponse',
    as HashRef[DeleteZoneOperationResponse()];

declare 'DeleteZoneVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeleteZoneVmExtensionPolicyRequest'];

coerce 'DeleteZoneVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeleteZoneVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedDeleteZoneVmExtensionPolicyRequest',
    as ArrayRef[DeleteZoneVmExtensionPolicyRequest()];

coerce 'RepeatedDeleteZoneVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeleteZoneVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringDeleteZoneVmExtensionPolicyRequest',
    as HashRef[DeleteZoneVmExtensionPolicyRequest()];

declare 'Denied',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Denied'];

coerce 'Denied',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Denied'->new($_) };

declare 'RepeatedDenied',
    as ArrayRef[Denied()];

coerce 'RepeatedDenied',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Denied'->new($_) } @$_ ] };

declare 'MapStringDenied',
    as HashRef[Denied()];

declare 'DeprecateImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeprecateImageRequest'];

coerce 'DeprecateImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeprecateImageRequest'->new($_) };

declare 'RepeatedDeprecateImageRequest',
    as ArrayRef[DeprecateImageRequest()];

coerce 'RepeatedDeprecateImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeprecateImageRequest'->new($_) } @$_ ] };

declare 'MapStringDeprecateImageRequest',
    as HashRef[DeprecateImageRequest()];

declare 'DeprecationStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DeprecationStatus'];

coerce 'DeprecationStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DeprecationStatus'->new($_) };

declare 'RepeatedDeprecationStatus',
    as ArrayRef[DeprecationStatus()];

coerce 'RepeatedDeprecationStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DeprecationStatus'->new($_) } @$_ ] };

declare 'MapStringDeprecationStatus',
    as HashRef[DeprecationStatus()];

declare 'State',
    as (Int | Str);

declare 'DetachDiskInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DetachDiskInstanceRequest'];

coerce 'DetachDiskInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DetachDiskInstanceRequest'->new($_) };

declare 'RepeatedDetachDiskInstanceRequest',
    as ArrayRef[DetachDiskInstanceRequest()];

coerce 'RepeatedDetachDiskInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DetachDiskInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringDetachDiskInstanceRequest',
    as HashRef[DetachDiskInstanceRequest()];

declare 'DetachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsGlobalNetworkEndpointGroupRequest'];

coerce 'DetachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsGlobalNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedDetachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    as ArrayRef[DetachNetworkEndpointsGlobalNetworkEndpointGroupRequest()];

coerce 'RepeatedDetachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsGlobalNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDetachNetworkEndpointsGlobalNetworkEndpointGroupRequest',
    as HashRef[DetachNetworkEndpointsGlobalNetworkEndpointGroupRequest()];

declare 'DetachNetworkEndpointsNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsNetworkEndpointGroupRequest'];

coerce 'DetachNetworkEndpointsNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedDetachNetworkEndpointsNetworkEndpointGroupRequest',
    as ArrayRef[DetachNetworkEndpointsNetworkEndpointGroupRequest()];

coerce 'RepeatedDetachNetworkEndpointsNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDetachNetworkEndpointsNetworkEndpointGroupRequest',
    as HashRef[DetachNetworkEndpointsNetworkEndpointGroupRequest()];

declare 'DetachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsRegionNetworkEndpointGroupRequest'];

coerce 'DetachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsRegionNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedDetachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    as ArrayRef[DetachNetworkEndpointsRegionNetworkEndpointGroupRequest()];

coerce 'RepeatedDetachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DetachNetworkEndpointsRegionNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringDetachNetworkEndpointsRegionNetworkEndpointGroupRequest',
    as HashRef[DetachNetworkEndpointsRegionNetworkEndpointGroupRequest()];

declare 'DisableXpnHostProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisableXpnHostProjectRequest'];

coerce 'DisableXpnHostProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisableXpnHostProjectRequest'->new($_) };

declare 'RepeatedDisableXpnHostProjectRequest',
    as ArrayRef[DisableXpnHostProjectRequest()];

coerce 'RepeatedDisableXpnHostProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisableXpnHostProjectRequest'->new($_) } @$_ ] };

declare 'MapStringDisableXpnHostProjectRequest',
    as HashRef[DisableXpnHostProjectRequest()];

declare 'DisableXpnResourceProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisableXpnResourceProjectRequest'];

coerce 'DisableXpnResourceProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisableXpnResourceProjectRequest'->new($_) };

declare 'RepeatedDisableXpnResourceProjectRequest',
    as ArrayRef[DisableXpnResourceProjectRequest()];

coerce 'RepeatedDisableXpnResourceProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisableXpnResourceProjectRequest'->new($_) } @$_ ] };

declare 'MapStringDisableXpnResourceProjectRequest',
    as HashRef[DisableXpnResourceProjectRequest()];

declare 'Disk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Disk'];

coerce 'Disk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Disk'->new($_) };

declare 'RepeatedDisk',
    as ArrayRef[Disk()];

coerce 'RepeatedDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Disk'->new($_) } @$_ ] };

declare 'MapStringDisk',
    as HashRef[Disk()];

declare 'AccessMode',
    as (Int | Str);

declare 'Architecture',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'AsyncSecondaryDisksEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Disk::AsyncSecondaryDisksEntry'];

coerce 'AsyncSecondaryDisksEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Disk::AsyncSecondaryDisksEntry'->new($_) };

declare 'RepeatedAsyncSecondaryDisksEntry',
    as ArrayRef[AsyncSecondaryDisksEntry()];

coerce 'RepeatedAsyncSecondaryDisksEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Disk::AsyncSecondaryDisksEntry'->new($_) } @$_ ] };

declare 'MapStringAsyncSecondaryDisksEntry',
    as HashRef[AsyncSecondaryDisksEntry()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Disk::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Disk::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Disk::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'DiskAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskAggregatedList'];

coerce 'DiskAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskAggregatedList'->new($_) };

declare 'RepeatedDiskAggregatedList',
    as ArrayRef[DiskAggregatedList()];

coerce 'RepeatedDiskAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskAggregatedList'->new($_) } @$_ ] };

declare 'MapStringDiskAggregatedList',
    as HashRef[DiskAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'DiskAsyncReplication',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskAsyncReplication'];

coerce 'DiskAsyncReplication',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskAsyncReplication'->new($_) };

declare 'RepeatedDiskAsyncReplication',
    as ArrayRef[DiskAsyncReplication()];

coerce 'RepeatedDiskAsyncReplication',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskAsyncReplication'->new($_) } @$_ ] };

declare 'MapStringDiskAsyncReplication',
    as HashRef[DiskAsyncReplication()];

declare 'DiskAsyncReplicationList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskAsyncReplicationList'];

coerce 'DiskAsyncReplicationList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskAsyncReplicationList'->new($_) };

declare 'RepeatedDiskAsyncReplicationList',
    as ArrayRef[DiskAsyncReplicationList()];

coerce 'RepeatedDiskAsyncReplicationList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskAsyncReplicationList'->new($_) } @$_ ] };

declare 'MapStringDiskAsyncReplicationList',
    as HashRef[DiskAsyncReplicationList()];

declare 'DiskInstantiationConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskInstantiationConfig'];

coerce 'DiskInstantiationConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskInstantiationConfig'->new($_) };

declare 'RepeatedDiskInstantiationConfig',
    as ArrayRef[DiskInstantiationConfig()];

coerce 'RepeatedDiskInstantiationConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskInstantiationConfig'->new($_) } @$_ ] };

declare 'MapStringDiskInstantiationConfig',
    as HashRef[DiskInstantiationConfig()];

declare 'InstantiateFrom',
    as (Int | Str);

declare 'DiskList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskList'];

coerce 'DiskList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskList'->new($_) };

declare 'RepeatedDiskList',
    as ArrayRef[DiskList()];

coerce 'RepeatedDiskList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskList'->new($_) } @$_ ] };

declare 'MapStringDiskList',
    as HashRef[DiskList()];

declare 'DiskMoveRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskMoveRequest'];

coerce 'DiskMoveRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskMoveRequest'->new($_) };

declare 'RepeatedDiskMoveRequest',
    as ArrayRef[DiskMoveRequest()];

coerce 'RepeatedDiskMoveRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskMoveRequest'->new($_) } @$_ ] };

declare 'MapStringDiskMoveRequest',
    as HashRef[DiskMoveRequest()];

declare 'DiskParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskParams'];

coerce 'DiskParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskParams'->new($_) };

declare 'RepeatedDiskParams',
    as ArrayRef[DiskParams()];

coerce 'RepeatedDiskParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskParams'->new($_) } @$_ ] };

declare 'MapStringDiskParams',
    as HashRef[DiskParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'DiskResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskResourceStatus'];

coerce 'DiskResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskResourceStatus'->new($_) };

declare 'RepeatedDiskResourceStatus',
    as ArrayRef[DiskResourceStatus()];

coerce 'RepeatedDiskResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskResourceStatus'->new($_) } @$_ ] };

declare 'MapStringDiskResourceStatus',
    as HashRef[DiskResourceStatus()];

declare 'AsyncSecondaryDisksEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskResourceStatus::AsyncSecondaryDisksEntry'];

coerce 'AsyncSecondaryDisksEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskResourceStatus::AsyncSecondaryDisksEntry'->new($_) };

declare 'RepeatedAsyncSecondaryDisksEntry',
    as ArrayRef[AsyncSecondaryDisksEntry()];

coerce 'RepeatedAsyncSecondaryDisksEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskResourceStatus::AsyncSecondaryDisksEntry'->new($_) } @$_ ] };

declare 'MapStringAsyncSecondaryDisksEntry',
    as HashRef[AsyncSecondaryDisksEntry()];

declare 'DiskResourceStatusAsyncReplicationStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskResourceStatusAsyncReplicationStatus'];

coerce 'DiskResourceStatusAsyncReplicationStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskResourceStatusAsyncReplicationStatus'->new($_) };

declare 'RepeatedDiskResourceStatusAsyncReplicationStatus',
    as ArrayRef[DiskResourceStatusAsyncReplicationStatus()];

coerce 'RepeatedDiskResourceStatusAsyncReplicationStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskResourceStatusAsyncReplicationStatus'->new($_) } @$_ ] };

declare 'MapStringDiskResourceStatusAsyncReplicationStatus',
    as HashRef[DiskResourceStatusAsyncReplicationStatus()];

declare 'State',
    as (Int | Str);

declare 'DiskType',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskType'];

coerce 'DiskType',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskType'->new($_) };

declare 'RepeatedDiskType',
    as ArrayRef[DiskType()];

coerce 'RepeatedDiskType',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskType'->new($_) } @$_ ] };

declare 'MapStringDiskType',
    as HashRef[DiskType()];

declare 'DiskTypeAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskTypeAggregatedList'];

coerce 'DiskTypeAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskTypeAggregatedList'->new($_) };

declare 'RepeatedDiskTypeAggregatedList',
    as ArrayRef[DiskTypeAggregatedList()];

coerce 'RepeatedDiskTypeAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskTypeAggregatedList'->new($_) } @$_ ] };

declare 'MapStringDiskTypeAggregatedList',
    as HashRef[DiskTypeAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskTypeAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskTypeAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskTypeAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'DiskTypeList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskTypeList'];

coerce 'DiskTypeList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskTypeList'->new($_) };

declare 'RepeatedDiskTypeList',
    as ArrayRef[DiskTypeList()];

coerce 'RepeatedDiskTypeList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskTypeList'->new($_) } @$_ ] };

declare 'MapStringDiskTypeList',
    as HashRef[DiskTypeList()];

declare 'DiskTypesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskTypesScopedList'];

coerce 'DiskTypesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskTypesScopedList'->new($_) };

declare 'RepeatedDiskTypesScopedList',
    as ArrayRef[DiskTypesScopedList()];

coerce 'RepeatedDiskTypesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskTypesScopedList'->new($_) } @$_ ] };

declare 'MapStringDiskTypesScopedList',
    as HashRef[DiskTypesScopedList()];

declare 'DiskUpdateKmsKeyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DiskUpdateKmsKeyRequest'];

coerce 'DiskUpdateKmsKeyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DiskUpdateKmsKeyRequest'->new($_) };

declare 'RepeatedDiskUpdateKmsKeyRequest',
    as ArrayRef[DiskUpdateKmsKeyRequest()];

coerce 'RepeatedDiskUpdateKmsKeyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DiskUpdateKmsKeyRequest'->new($_) } @$_ ] };

declare 'MapStringDiskUpdateKmsKeyRequest',
    as HashRef[DiskUpdateKmsKeyRequest()];

declare 'DisksAddResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisksAddResourcePoliciesRequest'];

coerce 'DisksAddResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisksAddResourcePoliciesRequest'->new($_) };

declare 'RepeatedDisksAddResourcePoliciesRequest',
    as ArrayRef[DisksAddResourcePoliciesRequest()];

coerce 'RepeatedDisksAddResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisksAddResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringDisksAddResourcePoliciesRequest',
    as HashRef[DisksAddResourcePoliciesRequest()];

declare 'DisksRemoveResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisksRemoveResourcePoliciesRequest'];

coerce 'DisksRemoveResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisksRemoveResourcePoliciesRequest'->new($_) };

declare 'RepeatedDisksRemoveResourcePoliciesRequest',
    as ArrayRef[DisksRemoveResourcePoliciesRequest()];

coerce 'RepeatedDisksRemoveResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisksRemoveResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringDisksRemoveResourcePoliciesRequest',
    as HashRef[DisksRemoveResourcePoliciesRequest()];

declare 'DisksResizeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisksResizeRequest'];

coerce 'DisksResizeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisksResizeRequest'->new($_) };

declare 'RepeatedDisksResizeRequest',
    as ArrayRef[DisksResizeRequest()];

coerce 'RepeatedDisksResizeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisksResizeRequest'->new($_) } @$_ ] };

declare 'MapStringDisksResizeRequest',
    as HashRef[DisksResizeRequest()];

declare 'DisksScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisksScopedList'];

coerce 'DisksScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisksScopedList'->new($_) };

declare 'RepeatedDisksScopedList',
    as ArrayRef[DisksScopedList()];

coerce 'RepeatedDisksScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisksScopedList'->new($_) } @$_ ] };

declare 'MapStringDisksScopedList',
    as HashRef[DisksScopedList()];

declare 'DisksStartAsyncReplicationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisksStartAsyncReplicationRequest'];

coerce 'DisksStartAsyncReplicationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisksStartAsyncReplicationRequest'->new($_) };

declare 'RepeatedDisksStartAsyncReplicationRequest',
    as ArrayRef[DisksStartAsyncReplicationRequest()];

coerce 'RepeatedDisksStartAsyncReplicationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisksStartAsyncReplicationRequest'->new($_) } @$_ ] };

declare 'MapStringDisksStartAsyncReplicationRequest',
    as HashRef[DisksStartAsyncReplicationRequest()];

declare 'DisksStopGroupAsyncReplicationResource',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisksStopGroupAsyncReplicationResource'];

coerce 'DisksStopGroupAsyncReplicationResource',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisksStopGroupAsyncReplicationResource'->new($_) };

declare 'RepeatedDisksStopGroupAsyncReplicationResource',
    as ArrayRef[DisksStopGroupAsyncReplicationResource()];

coerce 'RepeatedDisksStopGroupAsyncReplicationResource',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisksStopGroupAsyncReplicationResource'->new($_) } @$_ ] };

declare 'MapStringDisksStopGroupAsyncReplicationResource',
    as HashRef[DisksStopGroupAsyncReplicationResource()];

declare 'DisplayDevice',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DisplayDevice'];

coerce 'DisplayDevice',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DisplayDevice'->new($_) };

declare 'RepeatedDisplayDevice',
    as ArrayRef[DisplayDevice()];

coerce 'RepeatedDisplayDevice',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DisplayDevice'->new($_) } @$_ ] };

declare 'MapStringDisplayDevice',
    as HashRef[DisplayDevice()];

declare 'DistributionPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DistributionPolicy'];

coerce 'DistributionPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DistributionPolicy'->new($_) };

declare 'RepeatedDistributionPolicy',
    as ArrayRef[DistributionPolicy()];

coerce 'RepeatedDistributionPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DistributionPolicy'->new($_) } @$_ ] };

declare 'MapStringDistributionPolicy',
    as HashRef[DistributionPolicy()];

declare 'TargetShape',
    as (Int | Str);

declare 'DistributionPolicyZoneConfiguration',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::DistributionPolicyZoneConfiguration'];

coerce 'DistributionPolicyZoneConfiguration',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::DistributionPolicyZoneConfiguration'->new($_) };

declare 'RepeatedDistributionPolicyZoneConfiguration',
    as ArrayRef[DistributionPolicyZoneConfiguration()];

coerce 'RepeatedDistributionPolicyZoneConfiguration',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::DistributionPolicyZoneConfiguration'->new($_) } @$_ ] };

declare 'MapStringDistributionPolicyZoneConfiguration',
    as HashRef[DistributionPolicyZoneConfiguration()];

declare 'Duration',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Duration'];

coerce 'Duration',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Duration'->new($_) };

declare 'RepeatedDuration',
    as ArrayRef[Duration()];

coerce 'RepeatedDuration',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Duration'->new($_) } @$_ ] };

declare 'MapStringDuration',
    as HashRef[Duration()];

declare 'EnableXpnHostProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::EnableXpnHostProjectRequest'];

coerce 'EnableXpnHostProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::EnableXpnHostProjectRequest'->new($_) };

declare 'RepeatedEnableXpnHostProjectRequest',
    as ArrayRef[EnableXpnHostProjectRequest()];

coerce 'RepeatedEnableXpnHostProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::EnableXpnHostProjectRequest'->new($_) } @$_ ] };

declare 'MapStringEnableXpnHostProjectRequest',
    as HashRef[EnableXpnHostProjectRequest()];

declare 'EnableXpnResourceProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::EnableXpnResourceProjectRequest'];

coerce 'EnableXpnResourceProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::EnableXpnResourceProjectRequest'->new($_) };

declare 'RepeatedEnableXpnResourceProjectRequest',
    as ArrayRef[EnableXpnResourceProjectRequest()];

coerce 'RepeatedEnableXpnResourceProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::EnableXpnResourceProjectRequest'->new($_) } @$_ ] };

declare 'MapStringEnableXpnResourceProjectRequest',
    as HashRef[EnableXpnResourceProjectRequest()];

declare 'Error',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Error'];

coerce 'Error',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Error'->new($_) };

declare 'RepeatedError',
    as ArrayRef[Error()];

coerce 'RepeatedError',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Error'->new($_) } @$_ ] };

declare 'MapStringError',
    as HashRef[Error()];

declare 'ErrorDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ErrorDetails'];

coerce 'ErrorDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ErrorDetails'->new($_) };

declare 'RepeatedErrorDetails',
    as ArrayRef[ErrorDetails()];

coerce 'RepeatedErrorDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ErrorDetails'->new($_) } @$_ ] };

declare 'MapStringErrorDetails',
    as HashRef[ErrorDetails()];

declare 'ErrorInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ErrorInfo'];

coerce 'ErrorInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ErrorInfo'->new($_) };

declare 'RepeatedErrorInfo',
    as ArrayRef[ErrorInfo()];

coerce 'RepeatedErrorInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ErrorInfo'->new($_) } @$_ ] };

declare 'MapStringErrorInfo',
    as HashRef[ErrorInfo()];

declare 'MetadatasEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ErrorInfo::MetadatasEntry'];

coerce 'MetadatasEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ErrorInfo::MetadatasEntry'->new($_) };

declare 'RepeatedMetadatasEntry',
    as ArrayRef[MetadatasEntry()];

coerce 'RepeatedMetadatasEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ErrorInfo::MetadatasEntry'->new($_) } @$_ ] };

declare 'MapStringMetadatasEntry',
    as HashRef[MetadatasEntry()];

declare 'Errors',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Errors'];

coerce 'Errors',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Errors'->new($_) };

declare 'RepeatedErrors',
    as ArrayRef[Errors()];

coerce 'RepeatedErrors',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Errors'->new($_) } @$_ ] };

declare 'MapStringErrors',
    as HashRef[Errors()];

declare 'ExchangedPeeringRoute',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExchangedPeeringRoute'];

coerce 'ExchangedPeeringRoute',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExchangedPeeringRoute'->new($_) };

declare 'RepeatedExchangedPeeringRoute',
    as ArrayRef[ExchangedPeeringRoute()];

coerce 'RepeatedExchangedPeeringRoute',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExchangedPeeringRoute'->new($_) } @$_ ] };

declare 'MapStringExchangedPeeringRoute',
    as HashRef[ExchangedPeeringRoute()];

declare 'Type',
    as (Int | Str);

declare 'ExchangedPeeringRoutesList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExchangedPeeringRoutesList'];

coerce 'ExchangedPeeringRoutesList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExchangedPeeringRoutesList'->new($_) };

declare 'RepeatedExchangedPeeringRoutesList',
    as ArrayRef[ExchangedPeeringRoutesList()];

coerce 'RepeatedExchangedPeeringRoutesList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExchangedPeeringRoutesList'->new($_) } @$_ ] };

declare 'MapStringExchangedPeeringRoutesList',
    as HashRef[ExchangedPeeringRoutesList()];

declare 'ExpandIpCidrRangeSubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExpandIpCidrRangeSubnetworkRequest'];

coerce 'ExpandIpCidrRangeSubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExpandIpCidrRangeSubnetworkRequest'->new($_) };

declare 'RepeatedExpandIpCidrRangeSubnetworkRequest',
    as ArrayRef[ExpandIpCidrRangeSubnetworkRequest()];

coerce 'RepeatedExpandIpCidrRangeSubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExpandIpCidrRangeSubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringExpandIpCidrRangeSubnetworkRequest',
    as HashRef[ExpandIpCidrRangeSubnetworkRequest()];

declare 'Expr',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Expr'];

coerce 'Expr',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Expr'->new($_) };

declare 'RepeatedExpr',
    as ArrayRef[Expr()];

coerce 'RepeatedExpr',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Expr'->new($_) } @$_ ] };

declare 'MapStringExpr',
    as HashRef[Expr()];

declare 'ExternalVpnGateway',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExternalVpnGateway'];

coerce 'ExternalVpnGateway',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGateway'->new($_) };

declare 'RepeatedExternalVpnGateway',
    as ArrayRef[ExternalVpnGateway()];

coerce 'RepeatedExternalVpnGateway',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGateway'->new($_) } @$_ ] };

declare 'MapStringExternalVpnGateway',
    as HashRef[ExternalVpnGateway()];

declare 'RedundancyType',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExternalVpnGateway::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGateway::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGateway::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'ExternalVpnGatewayInterface',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayInterface'];

coerce 'ExternalVpnGatewayInterface',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayInterface'->new($_) };

declare 'RepeatedExternalVpnGatewayInterface',
    as ArrayRef[ExternalVpnGatewayInterface()];

coerce 'RepeatedExternalVpnGatewayInterface',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayInterface'->new($_) } @$_ ] };

declare 'MapStringExternalVpnGatewayInterface',
    as HashRef[ExternalVpnGatewayInterface()];

declare 'ExternalVpnGatewayList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayList'];

coerce 'ExternalVpnGatewayList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayList'->new($_) };

declare 'RepeatedExternalVpnGatewayList',
    as ArrayRef[ExternalVpnGatewayList()];

coerce 'RepeatedExternalVpnGatewayList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayList'->new($_) } @$_ ] };

declare 'MapStringExternalVpnGatewayList',
    as HashRef[ExternalVpnGatewayList()];

declare 'ExternalVpnGatewayParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayParams'];

coerce 'ExternalVpnGatewayParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayParams'->new($_) };

declare 'RepeatedExternalVpnGatewayParams',
    as ArrayRef[ExternalVpnGatewayParams()];

coerce 'RepeatedExternalVpnGatewayParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayParams'->new($_) } @$_ ] };

declare 'MapStringExternalVpnGatewayParams',
    as HashRef[ExternalVpnGatewayParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ExternalVpnGatewayParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'FileContentBuffer',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FileContentBuffer'];

coerce 'FileContentBuffer',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FileContentBuffer'->new($_) };

declare 'RepeatedFileContentBuffer',
    as ArrayRef[FileContentBuffer()];

coerce 'RepeatedFileContentBuffer',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FileContentBuffer'->new($_) } @$_ ] };

declare 'MapStringFileContentBuffer',
    as HashRef[FileContentBuffer()];

declare 'FileType',
    as (Int | Str);

declare 'Firewall',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Firewall'];

coerce 'Firewall',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Firewall'->new($_) };

declare 'RepeatedFirewall',
    as ArrayRef[Firewall()];

coerce 'RepeatedFirewall',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Firewall'->new($_) } @$_ ] };

declare 'MapStringFirewall',
    as HashRef[Firewall()];

declare 'Direction',
    as (Int | Str);

declare 'FirewallList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallList'];

coerce 'FirewallList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallList'->new($_) };

declare 'RepeatedFirewallList',
    as ArrayRef[FirewallList()];

coerce 'RepeatedFirewallList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallList'->new($_) } @$_ ] };

declare 'MapStringFirewallList',
    as HashRef[FirewallList()];

declare 'FirewallLogConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallLogConfig'];

coerce 'FirewallLogConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallLogConfig'->new($_) };

declare 'RepeatedFirewallLogConfig',
    as ArrayRef[FirewallLogConfig()];

coerce 'RepeatedFirewallLogConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallLogConfig'->new($_) } @$_ ] };

declare 'MapStringFirewallLogConfig',
    as HashRef[FirewallLogConfig()];

declare 'Metadata',
    as (Int | Str);

declare 'FirewallParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallParams'];

coerce 'FirewallParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallParams'->new($_) };

declare 'RepeatedFirewallParams',
    as ArrayRef[FirewallParams()];

coerce 'RepeatedFirewallParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallParams'->new($_) } @$_ ] };

declare 'MapStringFirewallParams',
    as HashRef[FirewallParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'FirewallPoliciesListAssociationsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPoliciesListAssociationsResponse'];

coerce 'FirewallPoliciesListAssociationsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPoliciesListAssociationsResponse'->new($_) };

declare 'RepeatedFirewallPoliciesListAssociationsResponse',
    as ArrayRef[FirewallPoliciesListAssociationsResponse()];

coerce 'RepeatedFirewallPoliciesListAssociationsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPoliciesListAssociationsResponse'->new($_) } @$_ ] };

declare 'MapStringFirewallPoliciesListAssociationsResponse',
    as HashRef[FirewallPoliciesListAssociationsResponse()];

declare 'FirewallPoliciesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPoliciesScopedList'];

coerce 'FirewallPoliciesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPoliciesScopedList'->new($_) };

declare 'RepeatedFirewallPoliciesScopedList',
    as ArrayRef[FirewallPoliciesScopedList()];

coerce 'RepeatedFirewallPoliciesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPoliciesScopedList'->new($_) } @$_ ] };

declare 'MapStringFirewallPoliciesScopedList',
    as HashRef[FirewallPoliciesScopedList()];

declare 'FirewallPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPolicy'];

coerce 'FirewallPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPolicy'->new($_) };

declare 'RepeatedFirewallPolicy',
    as ArrayRef[FirewallPolicy()];

coerce 'RepeatedFirewallPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPolicy'->new($_) } @$_ ] };

declare 'MapStringFirewallPolicy',
    as HashRef[FirewallPolicy()];

declare 'PolicyType',
    as (Int | Str);

declare 'FirewallPolicyAssociation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPolicyAssociation'];

coerce 'FirewallPolicyAssociation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyAssociation'->new($_) };

declare 'RepeatedFirewallPolicyAssociation',
    as ArrayRef[FirewallPolicyAssociation()];

coerce 'RepeatedFirewallPolicyAssociation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyAssociation'->new($_) } @$_ ] };

declare 'MapStringFirewallPolicyAssociation',
    as HashRef[FirewallPolicyAssociation()];

declare 'FirewallPolicyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPolicyList'];

coerce 'FirewallPolicyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyList'->new($_) };

declare 'RepeatedFirewallPolicyList',
    as ArrayRef[FirewallPolicyList()];

coerce 'RepeatedFirewallPolicyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyList'->new($_) } @$_ ] };

declare 'MapStringFirewallPolicyList',
    as HashRef[FirewallPolicyList()];

declare 'FirewallPolicyRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPolicyRule'];

coerce 'FirewallPolicyRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRule'->new($_) };

declare 'RepeatedFirewallPolicyRule',
    as ArrayRef[FirewallPolicyRule()];

coerce 'RepeatedFirewallPolicyRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRule'->new($_) } @$_ ] };

declare 'MapStringFirewallPolicyRule',
    as HashRef[FirewallPolicyRule()];

declare 'Direction',
    as (Int | Str);

declare 'TargetType',
    as (Int | Str);

declare 'FirewallPolicyRuleMatcher',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleMatcher'];

coerce 'FirewallPolicyRuleMatcher',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleMatcher'->new($_) };

declare 'RepeatedFirewallPolicyRuleMatcher',
    as ArrayRef[FirewallPolicyRuleMatcher()];

coerce 'RepeatedFirewallPolicyRuleMatcher',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleMatcher'->new($_) } @$_ ] };

declare 'MapStringFirewallPolicyRuleMatcher',
    as HashRef[FirewallPolicyRuleMatcher()];

declare 'DestNetworkContext',
    as (Int | Str);

declare 'DestNetworkType',
    as (Int | Str);

declare 'SrcNetworkContext',
    as (Int | Str);

declare 'SrcNetworkType',
    as (Int | Str);

declare 'FirewallPolicyRuleMatcherLayer4Config',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleMatcherLayer4Config'];

coerce 'FirewallPolicyRuleMatcherLayer4Config',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleMatcherLayer4Config'->new($_) };

declare 'RepeatedFirewallPolicyRuleMatcherLayer4Config',
    as ArrayRef[FirewallPolicyRuleMatcherLayer4Config()];

coerce 'RepeatedFirewallPolicyRuleMatcherLayer4Config',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleMatcherLayer4Config'->new($_) } @$_ ] };

declare 'MapStringFirewallPolicyRuleMatcherLayer4Config',
    as HashRef[FirewallPolicyRuleMatcherLayer4Config()];

declare 'FirewallPolicyRuleSecureTag',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleSecureTag'];

coerce 'FirewallPolicyRuleSecureTag',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleSecureTag'->new($_) };

declare 'RepeatedFirewallPolicyRuleSecureTag',
    as ArrayRef[FirewallPolicyRuleSecureTag()];

coerce 'RepeatedFirewallPolicyRuleSecureTag',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FirewallPolicyRuleSecureTag'->new($_) } @$_ ] };

declare 'MapStringFirewallPolicyRuleSecureTag',
    as HashRef[FirewallPolicyRuleSecureTag()];

declare 'State',
    as (Int | Str);

declare 'FixedOrPercent',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FixedOrPercent'];

coerce 'FixedOrPercent',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FixedOrPercent'->new($_) };

declare 'RepeatedFixedOrPercent',
    as ArrayRef[FixedOrPercent()];

coerce 'RepeatedFixedOrPercent',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FixedOrPercent'->new($_) } @$_ ] };

declare 'MapStringFixedOrPercent',
    as HashRef[FixedOrPercent()];

declare 'FlexibleTimeRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FlexibleTimeRange'];

coerce 'FlexibleTimeRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FlexibleTimeRange'->new($_) };

declare 'RepeatedFlexibleTimeRange',
    as ArrayRef[FlexibleTimeRange()];

coerce 'RepeatedFlexibleTimeRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FlexibleTimeRange'->new($_) } @$_ ] };

declare 'MapStringFlexibleTimeRange',
    as HashRef[FlexibleTimeRange()];

declare 'ForwardingRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRule'];

coerce 'ForwardingRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRule'->new($_) };

declare 'RepeatedForwardingRule',
    as ArrayRef[ForwardingRule()];

coerce 'RepeatedForwardingRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRule'->new($_) } @$_ ] };

declare 'MapStringForwardingRule',
    as HashRef[ForwardingRule()];

declare 'ExternalManagedBackendBucketMigrationState',
    as (Int | Str);

declare 'IPProtocolEnum',
    as (Int | Str);

declare 'IpVersion',
    as (Int | Str);

declare 'LoadBalancingScheme',
    as (Int | Str);

declare 'NetworkTier',
    as (Int | Str);

declare 'PscConnectionStatus',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRule::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRule::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRule::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'ForwardingRuleAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRuleAggregatedList'];

coerce 'ForwardingRuleAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleAggregatedList'->new($_) };

declare 'RepeatedForwardingRuleAggregatedList',
    as ArrayRef[ForwardingRuleAggregatedList()];

coerce 'RepeatedForwardingRuleAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleAggregatedList'->new($_) } @$_ ] };

declare 'MapStringForwardingRuleAggregatedList',
    as HashRef[ForwardingRuleAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRuleAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'ForwardingRuleAttachedExtension',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRuleAttachedExtension'];

coerce 'ForwardingRuleAttachedExtension',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleAttachedExtension'->new($_) };

declare 'RepeatedForwardingRuleAttachedExtension',
    as ArrayRef[ForwardingRuleAttachedExtension()];

coerce 'RepeatedForwardingRuleAttachedExtension',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleAttachedExtension'->new($_) } @$_ ] };

declare 'MapStringForwardingRuleAttachedExtension',
    as HashRef[ForwardingRuleAttachedExtension()];

declare 'ForwardingRuleList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRuleList'];

coerce 'ForwardingRuleList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleList'->new($_) };

declare 'RepeatedForwardingRuleList',
    as ArrayRef[ForwardingRuleList()];

coerce 'RepeatedForwardingRuleList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleList'->new($_) } @$_ ] };

declare 'MapStringForwardingRuleList',
    as HashRef[ForwardingRuleList()];

declare 'ForwardingRuleReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRuleReference'];

coerce 'ForwardingRuleReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleReference'->new($_) };

declare 'RepeatedForwardingRuleReference',
    as ArrayRef[ForwardingRuleReference()];

coerce 'RepeatedForwardingRuleReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleReference'->new($_) } @$_ ] };

declare 'MapStringForwardingRuleReference',
    as HashRef[ForwardingRuleReference()];

declare 'ForwardingRuleServiceDirectoryRegistration',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRuleServiceDirectoryRegistration'];

coerce 'ForwardingRuleServiceDirectoryRegistration',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleServiceDirectoryRegistration'->new($_) };

declare 'RepeatedForwardingRuleServiceDirectoryRegistration',
    as ArrayRef[ForwardingRuleServiceDirectoryRegistration()];

coerce 'RepeatedForwardingRuleServiceDirectoryRegistration',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRuleServiceDirectoryRegistration'->new($_) } @$_ ] };

declare 'MapStringForwardingRuleServiceDirectoryRegistration',
    as HashRef[ForwardingRuleServiceDirectoryRegistration()];

declare 'ForwardingRulesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ForwardingRulesScopedList'];

coerce 'ForwardingRulesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ForwardingRulesScopedList'->new($_) };

declare 'RepeatedForwardingRulesScopedList',
    as ArrayRef[ForwardingRulesScopedList()];

coerce 'RepeatedForwardingRulesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ForwardingRulesScopedList'->new($_) } @$_ ] };

declare 'MapStringForwardingRulesScopedList',
    as HashRef[ForwardingRulesScopedList()];

declare 'FutureReservation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservation'];

coerce 'FutureReservation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservation'->new($_) };

declare 'RepeatedFutureReservation',
    as ArrayRef[FutureReservation()];

coerce 'RepeatedFutureReservation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservation'->new($_) } @$_ ] };

declare 'MapStringFutureReservation',
    as HashRef[FutureReservation()];

declare 'ConfidentialComputeType',
    as (Int | Str);

declare 'DeploymentType',
    as (Int | Str);

declare 'PlanningStatus',
    as (Int | Str);

declare 'ReservationMode',
    as (Int | Str);

declare 'SchedulingType',
    as (Int | Str);

declare 'FutureReservationCommitmentInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationCommitmentInfo'];

coerce 'FutureReservationCommitmentInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationCommitmentInfo'->new($_) };

declare 'RepeatedFutureReservationCommitmentInfo',
    as ArrayRef[FutureReservationCommitmentInfo()];

coerce 'RepeatedFutureReservationCommitmentInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationCommitmentInfo'->new($_) } @$_ ] };

declare 'MapStringFutureReservationCommitmentInfo',
    as HashRef[FutureReservationCommitmentInfo()];

declare 'CommitmentPlan',
    as (Int | Str);

declare 'PreviousCommitmentTerms',
    as (Int | Str);

declare 'FutureReservationParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationParams'];

coerce 'FutureReservationParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationParams'->new($_) };

declare 'RepeatedFutureReservationParams',
    as ArrayRef[FutureReservationParams()];

coerce 'RepeatedFutureReservationParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationParams'->new($_) } @$_ ] };

declare 'MapStringFutureReservationParams',
    as HashRef[FutureReservationParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'FutureReservationSpecificSKUProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationSpecificSKUProperties'];

coerce 'FutureReservationSpecificSKUProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationSpecificSKUProperties'->new($_) };

declare 'RepeatedFutureReservationSpecificSKUProperties',
    as ArrayRef[FutureReservationSpecificSKUProperties()];

coerce 'RepeatedFutureReservationSpecificSKUProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationSpecificSKUProperties'->new($_) } @$_ ] };

declare 'MapStringFutureReservationSpecificSKUProperties',
    as HashRef[FutureReservationSpecificSKUProperties()];

declare 'FutureReservationStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationStatus'];

coerce 'FutureReservationStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatus'->new($_) };

declare 'RepeatedFutureReservationStatus',
    as ArrayRef[FutureReservationStatus()];

coerce 'RepeatedFutureReservationStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatus'->new($_) } @$_ ] };

declare 'MapStringFutureReservationStatus',
    as HashRef[FutureReservationStatus()];

declare 'AmendmentStatus',
    as (Int | Str);

declare 'ProcurementStatus',
    as (Int | Str);

declare 'FutureReservationStatusExistingMatchingUsageInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationStatusExistingMatchingUsageInfo'];

coerce 'FutureReservationStatusExistingMatchingUsageInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusExistingMatchingUsageInfo'->new($_) };

declare 'RepeatedFutureReservationStatusExistingMatchingUsageInfo',
    as ArrayRef[FutureReservationStatusExistingMatchingUsageInfo()];

coerce 'RepeatedFutureReservationStatusExistingMatchingUsageInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusExistingMatchingUsageInfo'->new($_) } @$_ ] };

declare 'MapStringFutureReservationStatusExistingMatchingUsageInfo',
    as HashRef[FutureReservationStatusExistingMatchingUsageInfo()];

declare 'FutureReservationStatusLastKnownGoodState',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationStatusLastKnownGoodState'];

coerce 'FutureReservationStatusLastKnownGoodState',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusLastKnownGoodState'->new($_) };

declare 'RepeatedFutureReservationStatusLastKnownGoodState',
    as ArrayRef[FutureReservationStatusLastKnownGoodState()];

coerce 'RepeatedFutureReservationStatusLastKnownGoodState',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusLastKnownGoodState'->new($_) } @$_ ] };

declare 'MapStringFutureReservationStatusLastKnownGoodState',
    as HashRef[FutureReservationStatusLastKnownGoodState()];

declare 'ProcurementStatus',
    as (Int | Str);

declare 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecs',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationStatusLastKnownGoodStateFutureReservationSpecs'];

coerce 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecs',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusLastKnownGoodStateFutureReservationSpecs'->new($_) };

declare 'RepeatedFutureReservationStatusLastKnownGoodStateFutureReservationSpecs',
    as ArrayRef[FutureReservationStatusLastKnownGoodStateFutureReservationSpecs()];

coerce 'RepeatedFutureReservationStatusLastKnownGoodStateFutureReservationSpecs',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusLastKnownGoodStateFutureReservationSpecs'->new($_) } @$_ ] };

declare 'MapStringFutureReservationStatusLastKnownGoodStateFutureReservationSpecs',
    as HashRef[FutureReservationStatusLastKnownGoodStateFutureReservationSpecs()];

declare 'FutureReservationStatusSpecificSKUProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationStatusSpecificSKUProperties'];

coerce 'FutureReservationStatusSpecificSKUProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusSpecificSKUProperties'->new($_) };

declare 'RepeatedFutureReservationStatusSpecificSKUProperties',
    as ArrayRef[FutureReservationStatusSpecificSKUProperties()];

coerce 'RepeatedFutureReservationStatusSpecificSKUProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationStatusSpecificSKUProperties'->new($_) } @$_ ] };

declare 'MapStringFutureReservationStatusSpecificSKUProperties',
    as HashRef[FutureReservationStatusSpecificSKUProperties()];

declare 'FutureReservationTimeWindow',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationTimeWindow'];

coerce 'FutureReservationTimeWindow',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationTimeWindow'->new($_) };

declare 'RepeatedFutureReservationTimeWindow',
    as ArrayRef[FutureReservationTimeWindow()];

coerce 'RepeatedFutureReservationTimeWindow',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationTimeWindow'->new($_) } @$_ ] };

declare 'MapStringFutureReservationTimeWindow',
    as HashRef[FutureReservationTimeWindow()];

declare 'FutureReservationsAggregatedListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationsAggregatedListResponse'];

coerce 'FutureReservationsAggregatedListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationsAggregatedListResponse'->new($_) };

declare 'RepeatedFutureReservationsAggregatedListResponse',
    as ArrayRef[FutureReservationsAggregatedListResponse()];

coerce 'RepeatedFutureReservationsAggregatedListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationsAggregatedListResponse'->new($_) } @$_ ] };

declare 'MapStringFutureReservationsAggregatedListResponse',
    as HashRef[FutureReservationsAggregatedListResponse()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationsAggregatedListResponse::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationsAggregatedListResponse::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationsAggregatedListResponse::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'FutureReservationsListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationsListResponse'];

coerce 'FutureReservationsListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationsListResponse'->new($_) };

declare 'RepeatedFutureReservationsListResponse',
    as ArrayRef[FutureReservationsListResponse()];

coerce 'RepeatedFutureReservationsListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationsListResponse'->new($_) } @$_ ] };

declare 'MapStringFutureReservationsListResponse',
    as HashRef[FutureReservationsListResponse()];

declare 'FutureReservationsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureReservationsScopedList'];

coerce 'FutureReservationsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureReservationsScopedList'->new($_) };

declare 'RepeatedFutureReservationsScopedList',
    as ArrayRef[FutureReservationsScopedList()];

coerce 'RepeatedFutureReservationsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureReservationsScopedList'->new($_) } @$_ ] };

declare 'MapStringFutureReservationsScopedList',
    as HashRef[FutureReservationsScopedList()];

declare 'FutureResourcesRecommendation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendation'];

coerce 'FutureResourcesRecommendation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendation'->new($_) };

declare 'RepeatedFutureResourcesRecommendation',
    as ArrayRef[FutureResourcesRecommendation()];

coerce 'RepeatedFutureResourcesRecommendation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendation'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesRecommendation',
    as HashRef[FutureResourcesRecommendation()];

declare 'RecommendationType',
    as (Int | Str);

declare 'OtherLocationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendation::OtherLocationsEntry'];

coerce 'OtherLocationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendation::OtherLocationsEntry'->new($_) };

declare 'RepeatedOtherLocationsEntry',
    as ArrayRef[OtherLocationsEntry()];

coerce 'RepeatedOtherLocationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendation::OtherLocationsEntry'->new($_) } @$_ ] };

declare 'MapStringOtherLocationsEntry',
    as HashRef[OtherLocationsEntry()];

declare 'FutureResourcesRecommendationOtherLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendationOtherLocation'];

coerce 'FutureResourcesRecommendationOtherLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendationOtherLocation'->new($_) };

declare 'RepeatedFutureResourcesRecommendationOtherLocation',
    as ArrayRef[FutureResourcesRecommendationOtherLocation()];

coerce 'RepeatedFutureResourcesRecommendationOtherLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesRecommendationOtherLocation'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesRecommendationOtherLocation',
    as HashRef[FutureResourcesRecommendationOtherLocation()];

declare 'Status',
    as (Int | Str);

declare 'FutureResourcesSpec',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpec'];

coerce 'FutureResourcesSpec',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpec'->new($_) };

declare 'RepeatedFutureResourcesSpec',
    as ArrayRef[FutureResourcesSpec()];

coerce 'RepeatedFutureResourcesSpec',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpec'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpec',
    as HashRef[FutureResourcesSpec()];

declare 'DeploymentType',
    as (Int | Str);

declare 'FutureResourcesSpecAggregateResources',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpecAggregateResources'];

coerce 'FutureResourcesSpecAggregateResources',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecAggregateResources'->new($_) };

declare 'RepeatedFutureResourcesSpecAggregateResources',
    as ArrayRef[FutureResourcesSpecAggregateResources()];

coerce 'RepeatedFutureResourcesSpecAggregateResources',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecAggregateResources'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpecAggregateResources',
    as HashRef[FutureResourcesSpecAggregateResources()];

declare 'VmFamily',
    as (Int | Str);

declare 'WorkloadType',
    as (Int | Str);

declare 'FutureResourcesSpecLocalSsdPartition',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocalSsdPartition'];

coerce 'FutureResourcesSpecLocalSsdPartition',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocalSsdPartition'->new($_) };

declare 'RepeatedFutureResourcesSpecLocalSsdPartition',
    as ArrayRef[FutureResourcesSpecLocalSsdPartition()];

coerce 'RepeatedFutureResourcesSpecLocalSsdPartition',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocalSsdPartition'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpecLocalSsdPartition',
    as HashRef[FutureResourcesSpecLocalSsdPartition()];

declare 'DiskInterface',
    as (Int | Str);

declare 'FutureResourcesSpecLocationPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicy'];

coerce 'FutureResourcesSpecLocationPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicy'->new($_) };

declare 'RepeatedFutureResourcesSpecLocationPolicy',
    as ArrayRef[FutureResourcesSpecLocationPolicy()];

coerce 'RepeatedFutureResourcesSpecLocationPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicy'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpecLocationPolicy',
    as HashRef[FutureResourcesSpecLocationPolicy()];

declare 'LocationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicy::LocationsEntry'];

coerce 'LocationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicy::LocationsEntry'->new($_) };

declare 'RepeatedLocationsEntry',
    as ArrayRef[LocationsEntry()];

coerce 'RepeatedLocationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicy::LocationsEntry'->new($_) } @$_ ] };

declare 'MapStringLocationsEntry',
    as HashRef[LocationsEntry()];

declare 'FutureResourcesSpecLocationPolicyLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicyLocation'];

coerce 'FutureResourcesSpecLocationPolicyLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicyLocation'->new($_) };

declare 'RepeatedFutureResourcesSpecLocationPolicyLocation',
    as ArrayRef[FutureResourcesSpecLocationPolicyLocation()];

coerce 'RepeatedFutureResourcesSpecLocationPolicyLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecLocationPolicyLocation'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpecLocationPolicyLocation',
    as HashRef[FutureResourcesSpecLocationPolicyLocation()];

declare 'Preference',
    as (Int | Str);

declare 'FutureResourcesSpecSpecificSKUResources',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpecSpecificSKUResources'];

coerce 'FutureResourcesSpecSpecificSKUResources',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecSpecificSKUResources'->new($_) };

declare 'RepeatedFutureResourcesSpecSpecificSKUResources',
    as ArrayRef[FutureResourcesSpecSpecificSKUResources()];

coerce 'RepeatedFutureResourcesSpecSpecificSKUResources',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecSpecificSKUResources'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpecSpecificSKUResources',
    as HashRef[FutureResourcesSpecSpecificSKUResources()];

declare 'FutureResourcesSpecTargetResources',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::FutureResourcesSpecTargetResources'];

coerce 'FutureResourcesSpecTargetResources',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecTargetResources'->new($_) };

declare 'RepeatedFutureResourcesSpecTargetResources',
    as ArrayRef[FutureResourcesSpecTargetResources()];

coerce 'RepeatedFutureResourcesSpecTargetResources',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::FutureResourcesSpecTargetResources'->new($_) } @$_ ] };

declare 'MapStringFutureResourcesSpecTargetResources',
    as HashRef[FutureResourcesSpecTargetResources()];

declare 'GRPCHealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GRPCHealthCheck'];

coerce 'GRPCHealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GRPCHealthCheck'->new($_) };

declare 'RepeatedGRPCHealthCheck',
    as ArrayRef[GRPCHealthCheck()];

coerce 'RepeatedGRPCHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GRPCHealthCheck'->new($_) } @$_ ] };

declare 'MapStringGRPCHealthCheck',
    as HashRef[GRPCHealthCheck()];

declare 'PortSpecification',
    as (Int | Str);

declare 'GRPCTLSHealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GRPCTLSHealthCheck'];

coerce 'GRPCTLSHealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GRPCTLSHealthCheck'->new($_) };

declare 'RepeatedGRPCTLSHealthCheck',
    as ArrayRef[GRPCTLSHealthCheck()];

coerce 'RepeatedGRPCTLSHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GRPCTLSHealthCheck'->new($_) } @$_ ] };

declare 'MapStringGRPCTLSHealthCheck',
    as HashRef[GRPCTLSHealthCheck()];

declare 'PortSpecification',
    as (Int | Str);

declare 'GetAcceleratorTypeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetAcceleratorTypeRequest'];

coerce 'GetAcceleratorTypeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetAcceleratorTypeRequest'->new($_) };

declare 'RepeatedGetAcceleratorTypeRequest',
    as ArrayRef[GetAcceleratorTypeRequest()];

coerce 'RepeatedGetAcceleratorTypeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetAcceleratorTypeRequest'->new($_) } @$_ ] };

declare 'MapStringGetAcceleratorTypeRequest',
    as HashRef[GetAcceleratorTypeRequest()];

declare 'GetAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetAddressRequest'];

coerce 'GetAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetAddressRequest'->new($_) };

declare 'RepeatedGetAddressRequest',
    as ArrayRef[GetAddressRequest()];

coerce 'RepeatedGetAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetAddressRequest'->new($_) } @$_ ] };

declare 'MapStringGetAddressRequest',
    as HashRef[GetAddressRequest()];

declare 'GetAssociationFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetAssociationFirewallPolicyRequest'];

coerce 'GetAssociationFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetAssociationFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetAssociationFirewallPolicyRequest',
    as ArrayRef[GetAssociationFirewallPolicyRequest()];

coerce 'RepeatedGetAssociationFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetAssociationFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetAssociationFirewallPolicyRequest',
    as HashRef[GetAssociationFirewallPolicyRequest()];

declare 'GetAssociationNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetAssociationNetworkFirewallPolicyRequest'];

coerce 'GetAssociationNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetAssociationNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetAssociationNetworkFirewallPolicyRequest',
    as ArrayRef[GetAssociationNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetAssociationNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetAssociationNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetAssociationNetworkFirewallPolicyRequest',
    as HashRef[GetAssociationNetworkFirewallPolicyRequest()];

declare 'GetAssociationOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetAssociationOrganizationSecurityPolicyRequest'];

coerce 'GetAssociationOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetAssociationOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedGetAssociationOrganizationSecurityPolicyRequest',
    as ArrayRef[GetAssociationOrganizationSecurityPolicyRequest()];

coerce 'RepeatedGetAssociationOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetAssociationOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetAssociationOrganizationSecurityPolicyRequest',
    as HashRef[GetAssociationOrganizationSecurityPolicyRequest()];

declare 'GetAssociationRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetAssociationRegionNetworkFirewallPolicyRequest'];

coerce 'GetAssociationRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetAssociationRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetAssociationRegionNetworkFirewallPolicyRequest',
    as ArrayRef[GetAssociationRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetAssociationRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetAssociationRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetAssociationRegionNetworkFirewallPolicyRequest',
    as HashRef[GetAssociationRegionNetworkFirewallPolicyRequest()];

declare 'GetAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetAutoscalerRequest'];

coerce 'GetAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetAutoscalerRequest'->new($_) };

declare 'RepeatedGetAutoscalerRequest',
    as ArrayRef[GetAutoscalerRequest()];

coerce 'RepeatedGetAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringGetAutoscalerRequest',
    as HashRef[GetAutoscalerRequest()];

declare 'GetBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetBackendBucketRequest'];

coerce 'GetBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetBackendBucketRequest'->new($_) };

declare 'RepeatedGetBackendBucketRequest',
    as ArrayRef[GetBackendBucketRequest()];

coerce 'RepeatedGetBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringGetBackendBucketRequest',
    as HashRef[GetBackendBucketRequest()];

declare 'GetBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetBackendServiceRequest'];

coerce 'GetBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetBackendServiceRequest'->new($_) };

declare 'RepeatedGetBackendServiceRequest',
    as ArrayRef[GetBackendServiceRequest()];

coerce 'RepeatedGetBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetBackendServiceRequest',
    as HashRef[GetBackendServiceRequest()];

declare 'GetCrossSiteNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetCrossSiteNetworkRequest'];

coerce 'GetCrossSiteNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetCrossSiteNetworkRequest'->new($_) };

declare 'RepeatedGetCrossSiteNetworkRequest',
    as ArrayRef[GetCrossSiteNetworkRequest()];

coerce 'RepeatedGetCrossSiteNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetCrossSiteNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringGetCrossSiteNetworkRequest',
    as HashRef[GetCrossSiteNetworkRequest()];

declare 'GetDiagnosticsInterconnectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetDiagnosticsInterconnectRequest'];

coerce 'GetDiagnosticsInterconnectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetDiagnosticsInterconnectRequest'->new($_) };

declare 'RepeatedGetDiagnosticsInterconnectRequest',
    as ArrayRef[GetDiagnosticsInterconnectRequest()];

coerce 'RepeatedGetDiagnosticsInterconnectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetDiagnosticsInterconnectRequest'->new($_) } @$_ ] };

declare 'MapStringGetDiagnosticsInterconnectRequest',
    as HashRef[GetDiagnosticsInterconnectRequest()];

declare 'GetDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetDiskRequest'];

coerce 'GetDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetDiskRequest'->new($_) };

declare 'RepeatedGetDiskRequest',
    as ArrayRef[GetDiskRequest()];

coerce 'RepeatedGetDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetDiskRequest'->new($_) } @$_ ] };

declare 'MapStringGetDiskRequest',
    as HashRef[GetDiskRequest()];

declare 'GetDiskTypeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetDiskTypeRequest'];

coerce 'GetDiskTypeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetDiskTypeRequest'->new($_) };

declare 'RepeatedGetDiskTypeRequest',
    as ArrayRef[GetDiskTypeRequest()];

coerce 'RepeatedGetDiskTypeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetDiskTypeRequest'->new($_) } @$_ ] };

declare 'MapStringGetDiskTypeRequest',
    as HashRef[GetDiskTypeRequest()];

declare 'GetEffectiveFirewallsInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsInstanceRequest'];

coerce 'GetEffectiveFirewallsInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsInstanceRequest'->new($_) };

declare 'RepeatedGetEffectiveFirewallsInstanceRequest',
    as ArrayRef[GetEffectiveFirewallsInstanceRequest()];

coerce 'RepeatedGetEffectiveFirewallsInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetEffectiveFirewallsInstanceRequest',
    as HashRef[GetEffectiveFirewallsInstanceRequest()];

declare 'GetEffectiveFirewallsNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsNetworkRequest'];

coerce 'GetEffectiveFirewallsNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsNetworkRequest'->new($_) };

declare 'RepeatedGetEffectiveFirewallsNetworkRequest',
    as ArrayRef[GetEffectiveFirewallsNetworkRequest()];

coerce 'RepeatedGetEffectiveFirewallsNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringGetEffectiveFirewallsNetworkRequest',
    as HashRef[GetEffectiveFirewallsNetworkRequest()];

declare 'GetEffectiveFirewallsRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsRegionNetworkFirewallPolicyRequest'];

coerce 'GetEffectiveFirewallsRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetEffectiveFirewallsRegionNetworkFirewallPolicyRequest',
    as ArrayRef[GetEffectiveFirewallsRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetEffectiveFirewallsRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetEffectiveFirewallsRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetEffectiveFirewallsRegionNetworkFirewallPolicyRequest',
    as HashRef[GetEffectiveFirewallsRegionNetworkFirewallPolicyRequest()];

declare 'GetEffectiveSecurityPoliciesBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetEffectiveSecurityPoliciesBackendServiceRequest'];

coerce 'GetEffectiveSecurityPoliciesBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetEffectiveSecurityPoliciesBackendServiceRequest'->new($_) };

declare 'RepeatedGetEffectiveSecurityPoliciesBackendServiceRequest',
    as ArrayRef[GetEffectiveSecurityPoliciesBackendServiceRequest()];

coerce 'RepeatedGetEffectiveSecurityPoliciesBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetEffectiveSecurityPoliciesBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetEffectiveSecurityPoliciesBackendServiceRequest',
    as HashRef[GetEffectiveSecurityPoliciesBackendServiceRequest()];

declare 'GetEffectiveSecurityPoliciesBackendServiceResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetEffectiveSecurityPoliciesBackendServiceResponse'];

coerce 'GetEffectiveSecurityPoliciesBackendServiceResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetEffectiveSecurityPoliciesBackendServiceResponse'->new($_) };

declare 'RepeatedGetEffectiveSecurityPoliciesBackendServiceResponse',
    as ArrayRef[GetEffectiveSecurityPoliciesBackendServiceResponse()];

coerce 'RepeatedGetEffectiveSecurityPoliciesBackendServiceResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetEffectiveSecurityPoliciesBackendServiceResponse'->new($_) } @$_ ] };

declare 'MapStringGetEffectiveSecurityPoliciesBackendServiceResponse',
    as HashRef[GetEffectiveSecurityPoliciesBackendServiceResponse()];

declare 'GetExternalVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetExternalVpnGatewayRequest'];

coerce 'GetExternalVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetExternalVpnGatewayRequest'->new($_) };

declare 'RepeatedGetExternalVpnGatewayRequest',
    as ArrayRef[GetExternalVpnGatewayRequest()];

coerce 'RepeatedGetExternalVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetExternalVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringGetExternalVpnGatewayRequest',
    as HashRef[GetExternalVpnGatewayRequest()];

declare 'GetFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetFirewallPolicyRequest'];

coerce 'GetFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetFirewallPolicyRequest',
    as ArrayRef[GetFirewallPolicyRequest()];

coerce 'RepeatedGetFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetFirewallPolicyRequest',
    as HashRef[GetFirewallPolicyRequest()];

declare 'GetFirewallRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetFirewallRequest'];

coerce 'GetFirewallRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetFirewallRequest'->new($_) };

declare 'RepeatedGetFirewallRequest',
    as ArrayRef[GetFirewallRequest()];

coerce 'RepeatedGetFirewallRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetFirewallRequest'->new($_) } @$_ ] };

declare 'MapStringGetFirewallRequest',
    as HashRef[GetFirewallRequest()];

declare 'GetForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetForwardingRuleRequest'];

coerce 'GetForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetForwardingRuleRequest'->new($_) };

declare 'RepeatedGetForwardingRuleRequest',
    as ArrayRef[GetForwardingRuleRequest()];

coerce 'RepeatedGetForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringGetForwardingRuleRequest',
    as HashRef[GetForwardingRuleRequest()];

declare 'View',
    as (Int | Str);

declare 'GetFromFamilyImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetFromFamilyImageRequest'];

coerce 'GetFromFamilyImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetFromFamilyImageRequest'->new($_) };

declare 'RepeatedGetFromFamilyImageRequest',
    as ArrayRef[GetFromFamilyImageRequest()];

coerce 'RepeatedGetFromFamilyImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetFromFamilyImageRequest'->new($_) } @$_ ] };

declare 'MapStringGetFromFamilyImageRequest',
    as HashRef[GetFromFamilyImageRequest()];

declare 'GetFutureReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetFutureReservationRequest'];

coerce 'GetFutureReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetFutureReservationRequest'->new($_) };

declare 'RepeatedGetFutureReservationRequest',
    as ArrayRef[GetFutureReservationRequest()];

coerce 'RepeatedGetFutureReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetFutureReservationRequest'->new($_) } @$_ ] };

declare 'MapStringGetFutureReservationRequest',
    as HashRef[GetFutureReservationRequest()];

declare 'GetGlobalAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGlobalAddressRequest'];

coerce 'GetGlobalAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGlobalAddressRequest'->new($_) };

declare 'RepeatedGetGlobalAddressRequest',
    as ArrayRef[GetGlobalAddressRequest()];

coerce 'RepeatedGetGlobalAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGlobalAddressRequest'->new($_) } @$_ ] };

declare 'MapStringGetGlobalAddressRequest',
    as HashRef[GetGlobalAddressRequest()];

declare 'GetGlobalForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGlobalForwardingRuleRequest'];

coerce 'GetGlobalForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGlobalForwardingRuleRequest'->new($_) };

declare 'RepeatedGetGlobalForwardingRuleRequest',
    as ArrayRef[GetGlobalForwardingRuleRequest()];

coerce 'RepeatedGetGlobalForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGlobalForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringGetGlobalForwardingRuleRequest',
    as HashRef[GetGlobalForwardingRuleRequest()];

declare 'View',
    as (Int | Str);

declare 'GetGlobalNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGlobalNetworkEndpointGroupRequest'];

coerce 'GetGlobalNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGlobalNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedGetGlobalNetworkEndpointGroupRequest',
    as ArrayRef[GetGlobalNetworkEndpointGroupRequest()];

coerce 'RepeatedGetGlobalNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGlobalNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetGlobalNetworkEndpointGroupRequest',
    as HashRef[GetGlobalNetworkEndpointGroupRequest()];

declare 'GetGlobalOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGlobalOperationRequest'];

coerce 'GetGlobalOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGlobalOperationRequest'->new($_) };

declare 'RepeatedGetGlobalOperationRequest',
    as ArrayRef[GetGlobalOperationRequest()];

coerce 'RepeatedGetGlobalOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGlobalOperationRequest'->new($_) } @$_ ] };

declare 'MapStringGetGlobalOperationRequest',
    as HashRef[GetGlobalOperationRequest()];

declare 'GetGlobalOrganizationOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGlobalOrganizationOperationRequest'];

coerce 'GetGlobalOrganizationOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGlobalOrganizationOperationRequest'->new($_) };

declare 'RepeatedGetGlobalOrganizationOperationRequest',
    as ArrayRef[GetGlobalOrganizationOperationRequest()];

coerce 'RepeatedGetGlobalOrganizationOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGlobalOrganizationOperationRequest'->new($_) } @$_ ] };

declare 'MapStringGetGlobalOrganizationOperationRequest',
    as HashRef[GetGlobalOrganizationOperationRequest()];

declare 'GetGlobalPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGlobalPublicDelegatedPrefixeRequest'];

coerce 'GetGlobalPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGlobalPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedGetGlobalPublicDelegatedPrefixeRequest',
    as ArrayRef[GetGlobalPublicDelegatedPrefixeRequest()];

coerce 'RepeatedGetGlobalPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGlobalPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringGetGlobalPublicDelegatedPrefixeRequest',
    as HashRef[GetGlobalPublicDelegatedPrefixeRequest()];

declare 'GetGlobalVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGlobalVmExtensionPolicyRequest'];

coerce 'GetGlobalVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGlobalVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedGetGlobalVmExtensionPolicyRequest',
    as ArrayRef[GetGlobalVmExtensionPolicyRequest()];

coerce 'RepeatedGetGlobalVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGlobalVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetGlobalVmExtensionPolicyRequest',
    as HashRef[GetGlobalVmExtensionPolicyRequest()];

declare 'GetGuestAttributesInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetGuestAttributesInstanceRequest'];

coerce 'GetGuestAttributesInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetGuestAttributesInstanceRequest'->new($_) };

declare 'RepeatedGetGuestAttributesInstanceRequest',
    as ArrayRef[GetGuestAttributesInstanceRequest()];

coerce 'RepeatedGetGuestAttributesInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetGuestAttributesInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetGuestAttributesInstanceRequest',
    as HashRef[GetGuestAttributesInstanceRequest()];

declare 'GetHealthBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetHealthBackendServiceRequest'];

coerce 'GetHealthBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetHealthBackendServiceRequest'->new($_) };

declare 'RepeatedGetHealthBackendServiceRequest',
    as ArrayRef[GetHealthBackendServiceRequest()];

coerce 'RepeatedGetHealthBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetHealthBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetHealthBackendServiceRequest',
    as HashRef[GetHealthBackendServiceRequest()];

declare 'GetHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetHealthCheckRequest'];

coerce 'GetHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetHealthCheckRequest'->new($_) };

declare 'RepeatedGetHealthCheckRequest',
    as ArrayRef[GetHealthCheckRequest()];

coerce 'RepeatedGetHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringGetHealthCheckRequest',
    as HashRef[GetHealthCheckRequest()];

declare 'GetHealthRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetHealthRegionBackendServiceRequest'];

coerce 'GetHealthRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetHealthRegionBackendServiceRequest'->new($_) };

declare 'RepeatedGetHealthRegionBackendServiceRequest',
    as ArrayRef[GetHealthRegionBackendServiceRequest()];

coerce 'RepeatedGetHealthRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetHealthRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetHealthRegionBackendServiceRequest',
    as HashRef[GetHealthRegionBackendServiceRequest()];

declare 'GetHealthRegionCompositeHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetHealthRegionCompositeHealthCheckRequest'];

coerce 'GetHealthRegionCompositeHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetHealthRegionCompositeHealthCheckRequest'->new($_) };

declare 'RepeatedGetHealthRegionCompositeHealthCheckRequest',
    as ArrayRef[GetHealthRegionCompositeHealthCheckRequest()];

coerce 'RepeatedGetHealthRegionCompositeHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetHealthRegionCompositeHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringGetHealthRegionCompositeHealthCheckRequest',
    as HashRef[GetHealthRegionCompositeHealthCheckRequest()];

declare 'GetHealthRegionHealthSourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetHealthRegionHealthSourceRequest'];

coerce 'GetHealthRegionHealthSourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetHealthRegionHealthSourceRequest'->new($_) };

declare 'RepeatedGetHealthRegionHealthSourceRequest',
    as ArrayRef[GetHealthRegionHealthSourceRequest()];

coerce 'RepeatedGetHealthRegionHealthSourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetHealthRegionHealthSourceRequest'->new($_) } @$_ ] };

declare 'MapStringGetHealthRegionHealthSourceRequest',
    as HashRef[GetHealthRegionHealthSourceRequest()];

declare 'GetHealthTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetHealthTargetPoolRequest'];

coerce 'GetHealthTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetHealthTargetPoolRequest'->new($_) };

declare 'RepeatedGetHealthTargetPoolRequest',
    as ArrayRef[GetHealthTargetPoolRequest()];

coerce 'RepeatedGetHealthTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetHealthTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringGetHealthTargetPoolRequest',
    as HashRef[GetHealthTargetPoolRequest()];

declare 'GetIamPolicyBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyBackendBucketRequest'];

coerce 'GetIamPolicyBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyBackendBucketRequest'->new($_) };

declare 'RepeatedGetIamPolicyBackendBucketRequest',
    as ArrayRef[GetIamPolicyBackendBucketRequest()];

coerce 'RepeatedGetIamPolicyBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyBackendBucketRequest',
    as HashRef[GetIamPolicyBackendBucketRequest()];

declare 'GetIamPolicyBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyBackendServiceRequest'];

coerce 'GetIamPolicyBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyBackendServiceRequest'->new($_) };

declare 'RepeatedGetIamPolicyBackendServiceRequest',
    as ArrayRef[GetIamPolicyBackendServiceRequest()];

coerce 'RepeatedGetIamPolicyBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyBackendServiceRequest',
    as HashRef[GetIamPolicyBackendServiceRequest()];

declare 'GetIamPolicyDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyDiskRequest'];

coerce 'GetIamPolicyDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyDiskRequest'->new($_) };

declare 'RepeatedGetIamPolicyDiskRequest',
    as ArrayRef[GetIamPolicyDiskRequest()];

coerce 'RepeatedGetIamPolicyDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyDiskRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyDiskRequest',
    as HashRef[GetIamPolicyDiskRequest()];

declare 'GetIamPolicyFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyFirewallPolicyRequest'];

coerce 'GetIamPolicyFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetIamPolicyFirewallPolicyRequest',
    as ArrayRef[GetIamPolicyFirewallPolicyRequest()];

coerce 'RepeatedGetIamPolicyFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyFirewallPolicyRequest',
    as HashRef[GetIamPolicyFirewallPolicyRequest()];

declare 'GetIamPolicyImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyImageRequest'];

coerce 'GetIamPolicyImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyImageRequest'->new($_) };

declare 'RepeatedGetIamPolicyImageRequest',
    as ArrayRef[GetIamPolicyImageRequest()];

coerce 'RepeatedGetIamPolicyImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyImageRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyImageRequest',
    as HashRef[GetIamPolicyImageRequest()];

declare 'GetIamPolicyInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyInstanceRequest'];

coerce 'GetIamPolicyInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstanceRequest'->new($_) };

declare 'RepeatedGetIamPolicyInstanceRequest',
    as ArrayRef[GetIamPolicyInstanceRequest()];

coerce 'RepeatedGetIamPolicyInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyInstanceRequest',
    as HashRef[GetIamPolicyInstanceRequest()];

declare 'GetIamPolicyInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyInstanceTemplateRequest'];

coerce 'GetIamPolicyInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstanceTemplateRequest'->new($_) };

declare 'RepeatedGetIamPolicyInstanceTemplateRequest',
    as ArrayRef[GetIamPolicyInstanceTemplateRequest()];

coerce 'RepeatedGetIamPolicyInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyInstanceTemplateRequest',
    as HashRef[GetIamPolicyInstanceTemplateRequest()];

declare 'GetIamPolicyInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyInstantSnapshotGroupRequest'];

coerce 'GetIamPolicyInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedGetIamPolicyInstantSnapshotGroupRequest',
    as ArrayRef[GetIamPolicyInstantSnapshotGroupRequest()];

coerce 'RepeatedGetIamPolicyInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyInstantSnapshotGroupRequest',
    as HashRef[GetIamPolicyInstantSnapshotGroupRequest()];

declare 'GetIamPolicyInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyInstantSnapshotRequest'];

coerce 'GetIamPolicyInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstantSnapshotRequest'->new($_) };

declare 'RepeatedGetIamPolicyInstantSnapshotRequest',
    as ArrayRef[GetIamPolicyInstantSnapshotRequest()];

coerce 'RepeatedGetIamPolicyInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyInstantSnapshotRequest',
    as HashRef[GetIamPolicyInstantSnapshotRequest()];

declare 'GetIamPolicyInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyInterconnectAttachmentGroupRequest'];

coerce 'GetIamPolicyInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedGetIamPolicyInterconnectAttachmentGroupRequest',
    as ArrayRef[GetIamPolicyInterconnectAttachmentGroupRequest()];

coerce 'RepeatedGetIamPolicyInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyInterconnectAttachmentGroupRequest',
    as HashRef[GetIamPolicyInterconnectAttachmentGroupRequest()];

declare 'GetIamPolicyInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyInterconnectGroupRequest'];

coerce 'GetIamPolicyInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInterconnectGroupRequest'->new($_) };

declare 'RepeatedGetIamPolicyInterconnectGroupRequest',
    as ArrayRef[GetIamPolicyInterconnectGroupRequest()];

coerce 'RepeatedGetIamPolicyInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyInterconnectGroupRequest',
    as HashRef[GetIamPolicyInterconnectGroupRequest()];

declare 'GetIamPolicyLicenseCodeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyLicenseCodeRequest'];

coerce 'GetIamPolicyLicenseCodeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyLicenseCodeRequest'->new($_) };

declare 'RepeatedGetIamPolicyLicenseCodeRequest',
    as ArrayRef[GetIamPolicyLicenseCodeRequest()];

coerce 'RepeatedGetIamPolicyLicenseCodeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyLicenseCodeRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyLicenseCodeRequest',
    as HashRef[GetIamPolicyLicenseCodeRequest()];

declare 'GetIamPolicyLicenseRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyLicenseRequest'];

coerce 'GetIamPolicyLicenseRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyLicenseRequest'->new($_) };

declare 'RepeatedGetIamPolicyLicenseRequest',
    as ArrayRef[GetIamPolicyLicenseRequest()];

coerce 'RepeatedGetIamPolicyLicenseRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyLicenseRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyLicenseRequest',
    as HashRef[GetIamPolicyLicenseRequest()];

declare 'GetIamPolicyMachineImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyMachineImageRequest'];

coerce 'GetIamPolicyMachineImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyMachineImageRequest'->new($_) };

declare 'RepeatedGetIamPolicyMachineImageRequest',
    as ArrayRef[GetIamPolicyMachineImageRequest()];

coerce 'RepeatedGetIamPolicyMachineImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyMachineImageRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyMachineImageRequest',
    as HashRef[GetIamPolicyMachineImageRequest()];

declare 'GetIamPolicyNetworkAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyNetworkAttachmentRequest'];

coerce 'GetIamPolicyNetworkAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNetworkAttachmentRequest'->new($_) };

declare 'RepeatedGetIamPolicyNetworkAttachmentRequest',
    as ArrayRef[GetIamPolicyNetworkAttachmentRequest()];

coerce 'RepeatedGetIamPolicyNetworkAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNetworkAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyNetworkAttachmentRequest',
    as HashRef[GetIamPolicyNetworkAttachmentRequest()];

declare 'GetIamPolicyNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyNetworkFirewallPolicyRequest'];

coerce 'GetIamPolicyNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetIamPolicyNetworkFirewallPolicyRequest',
    as ArrayRef[GetIamPolicyNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetIamPolicyNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyNetworkFirewallPolicyRequest',
    as HashRef[GetIamPolicyNetworkFirewallPolicyRequest()];

declare 'GetIamPolicyNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyNodeGroupRequest'];

coerce 'GetIamPolicyNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNodeGroupRequest'->new($_) };

declare 'RepeatedGetIamPolicyNodeGroupRequest',
    as ArrayRef[GetIamPolicyNodeGroupRequest()];

coerce 'RepeatedGetIamPolicyNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyNodeGroupRequest',
    as HashRef[GetIamPolicyNodeGroupRequest()];

declare 'GetIamPolicyNodeTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyNodeTemplateRequest'];

coerce 'GetIamPolicyNodeTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNodeTemplateRequest'->new($_) };

declare 'RepeatedGetIamPolicyNodeTemplateRequest',
    as ArrayRef[GetIamPolicyNodeTemplateRequest()];

coerce 'RepeatedGetIamPolicyNodeTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyNodeTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyNodeTemplateRequest',
    as HashRef[GetIamPolicyNodeTemplateRequest()];

declare 'GetIamPolicyRegionBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionBackendBucketRequest'];

coerce 'GetIamPolicyRegionBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionBackendBucketRequest'->new($_) };

declare 'RepeatedGetIamPolicyRegionBackendBucketRequest',
    as ArrayRef[GetIamPolicyRegionBackendBucketRequest()];

coerce 'RepeatedGetIamPolicyRegionBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyRegionBackendBucketRequest',
    as HashRef[GetIamPolicyRegionBackendBucketRequest()];

declare 'GetIamPolicyRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionBackendServiceRequest'];

coerce 'GetIamPolicyRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionBackendServiceRequest'->new($_) };

declare 'RepeatedGetIamPolicyRegionBackendServiceRequest',
    as ArrayRef[GetIamPolicyRegionBackendServiceRequest()];

coerce 'RepeatedGetIamPolicyRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyRegionBackendServiceRequest',
    as HashRef[GetIamPolicyRegionBackendServiceRequest()];

declare 'GetIamPolicyRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionDiskRequest'];

coerce 'GetIamPolicyRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionDiskRequest'->new($_) };

declare 'RepeatedGetIamPolicyRegionDiskRequest',
    as ArrayRef[GetIamPolicyRegionDiskRequest()];

coerce 'RepeatedGetIamPolicyRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyRegionDiskRequest',
    as HashRef[GetIamPolicyRegionDiskRequest()];

declare 'GetIamPolicyRegionInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionInstantSnapshotGroupRequest'];

coerce 'GetIamPolicyRegionInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedGetIamPolicyRegionInstantSnapshotGroupRequest',
    as ArrayRef[GetIamPolicyRegionInstantSnapshotGroupRequest()];

coerce 'RepeatedGetIamPolicyRegionInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyRegionInstantSnapshotGroupRequest',
    as HashRef[GetIamPolicyRegionInstantSnapshotGroupRequest()];

declare 'GetIamPolicyRegionInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionInstantSnapshotRequest'];

coerce 'GetIamPolicyRegionInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionInstantSnapshotRequest'->new($_) };

declare 'RepeatedGetIamPolicyRegionInstantSnapshotRequest',
    as ArrayRef[GetIamPolicyRegionInstantSnapshotRequest()];

coerce 'RepeatedGetIamPolicyRegionInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyRegionInstantSnapshotRequest',
    as HashRef[GetIamPolicyRegionInstantSnapshotRequest()];

declare 'GetIamPolicyRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionNetworkFirewallPolicyRequest'];

coerce 'GetIamPolicyRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetIamPolicyRegionNetworkFirewallPolicyRequest',
    as ArrayRef[GetIamPolicyRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetIamPolicyRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyRegionNetworkFirewallPolicyRequest',
    as HashRef[GetIamPolicyRegionNetworkFirewallPolicyRequest()];

declare 'GetIamPolicyRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionSnapshotRequest'];

coerce 'GetIamPolicyRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionSnapshotRequest'->new($_) };

declare 'RepeatedGetIamPolicyRegionSnapshotRequest',
    as ArrayRef[GetIamPolicyRegionSnapshotRequest()];

coerce 'RepeatedGetIamPolicyRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyRegionSnapshotRequest',
    as HashRef[GetIamPolicyRegionSnapshotRequest()];

declare 'GetIamPolicyReservationBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationBlockRequest'];

coerce 'GetIamPolicyReservationBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationBlockRequest'->new($_) };

declare 'RepeatedGetIamPolicyReservationBlockRequest',
    as ArrayRef[GetIamPolicyReservationBlockRequest()];

coerce 'RepeatedGetIamPolicyReservationBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationBlockRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyReservationBlockRequest',
    as HashRef[GetIamPolicyReservationBlockRequest()];

declare 'GetIamPolicyReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationRequest'];

coerce 'GetIamPolicyReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationRequest'->new($_) };

declare 'RepeatedGetIamPolicyReservationRequest',
    as ArrayRef[GetIamPolicyReservationRequest()];

coerce 'RepeatedGetIamPolicyReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyReservationRequest',
    as HashRef[GetIamPolicyReservationRequest()];

declare 'GetIamPolicyReservationSubBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationSubBlockRequest'];

coerce 'GetIamPolicyReservationSubBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationSubBlockRequest'->new($_) };

declare 'RepeatedGetIamPolicyReservationSubBlockRequest',
    as ArrayRef[GetIamPolicyReservationSubBlockRequest()];

coerce 'RepeatedGetIamPolicyReservationSubBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyReservationSubBlockRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyReservationSubBlockRequest',
    as HashRef[GetIamPolicyReservationSubBlockRequest()];

declare 'GetIamPolicyResourcePolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyResourcePolicyRequest'];

coerce 'GetIamPolicyResourcePolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyResourcePolicyRequest'->new($_) };

declare 'RepeatedGetIamPolicyResourcePolicyRequest',
    as ArrayRef[GetIamPolicyResourcePolicyRequest()];

coerce 'RepeatedGetIamPolicyResourcePolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyResourcePolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyResourcePolicyRequest',
    as HashRef[GetIamPolicyResourcePolicyRequest()];

declare 'GetIamPolicyServiceAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyServiceAttachmentRequest'];

coerce 'GetIamPolicyServiceAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyServiceAttachmentRequest'->new($_) };

declare 'RepeatedGetIamPolicyServiceAttachmentRequest',
    as ArrayRef[GetIamPolicyServiceAttachmentRequest()];

coerce 'RepeatedGetIamPolicyServiceAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyServiceAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyServiceAttachmentRequest',
    as HashRef[GetIamPolicyServiceAttachmentRequest()];

declare 'GetIamPolicySnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicySnapshotRequest'];

coerce 'GetIamPolicySnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicySnapshotRequest'->new($_) };

declare 'RepeatedGetIamPolicySnapshotRequest',
    as ArrayRef[GetIamPolicySnapshotRequest()];

coerce 'RepeatedGetIamPolicySnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicySnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicySnapshotRequest',
    as HashRef[GetIamPolicySnapshotRequest()];

declare 'GetIamPolicyStoragePoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicyStoragePoolRequest'];

coerce 'GetIamPolicyStoragePoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyStoragePoolRequest'->new($_) };

declare 'RepeatedGetIamPolicyStoragePoolRequest',
    as ArrayRef[GetIamPolicyStoragePoolRequest()];

coerce 'RepeatedGetIamPolicyStoragePoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicyStoragePoolRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicyStoragePoolRequest',
    as HashRef[GetIamPolicyStoragePoolRequest()];

declare 'GetIamPolicySubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetIamPolicySubnetworkRequest'];

coerce 'GetIamPolicySubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetIamPolicySubnetworkRequest'->new($_) };

declare 'RepeatedGetIamPolicySubnetworkRequest',
    as ArrayRef[GetIamPolicySubnetworkRequest()];

coerce 'RepeatedGetIamPolicySubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetIamPolicySubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringGetIamPolicySubnetworkRequest',
    as HashRef[GetIamPolicySubnetworkRequest()];

declare 'GetImageFamilyViewRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetImageFamilyViewRequest'];

coerce 'GetImageFamilyViewRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetImageFamilyViewRequest'->new($_) };

declare 'RepeatedGetImageFamilyViewRequest',
    as ArrayRef[GetImageFamilyViewRequest()];

coerce 'RepeatedGetImageFamilyViewRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetImageFamilyViewRequest'->new($_) } @$_ ] };

declare 'MapStringGetImageFamilyViewRequest',
    as HashRef[GetImageFamilyViewRequest()];

declare 'GetImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetImageRequest'];

coerce 'GetImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetImageRequest'->new($_) };

declare 'RepeatedGetImageRequest',
    as ArrayRef[GetImageRequest()];

coerce 'RepeatedGetImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetImageRequest'->new($_) } @$_ ] };

declare 'MapStringGetImageRequest',
    as HashRef[GetImageRequest()];

declare 'GetInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstanceGroupManagerRequest'];

coerce 'GetInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedGetInstanceGroupManagerRequest',
    as ArrayRef[GetInstanceGroupManagerRequest()];

coerce 'RepeatedGetInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstanceGroupManagerRequest',
    as HashRef[GetInstanceGroupManagerRequest()];

declare 'GetInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstanceGroupManagerResizeRequestRequest'];

coerce 'GetInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedGetInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[GetInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedGetInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstanceGroupManagerResizeRequestRequest',
    as HashRef[GetInstanceGroupManagerResizeRequestRequest()];

declare 'GetInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstanceGroupRequest'];

coerce 'GetInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstanceGroupRequest'->new($_) };

declare 'RepeatedGetInstanceGroupRequest',
    as ArrayRef[GetInstanceGroupRequest()];

coerce 'RepeatedGetInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstanceGroupRequest',
    as HashRef[GetInstanceGroupRequest()];

declare 'GetInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstanceRequest'];

coerce 'GetInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstanceRequest'->new($_) };

declare 'RepeatedGetInstanceRequest',
    as ArrayRef[GetInstanceRequest()];

coerce 'RepeatedGetInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstanceRequest',
    as HashRef[GetInstanceRequest()];

declare 'GetInstanceSettingRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstanceSettingRequest'];

coerce 'GetInstanceSettingRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstanceSettingRequest'->new($_) };

declare 'RepeatedGetInstanceSettingRequest',
    as ArrayRef[GetInstanceSettingRequest()];

coerce 'RepeatedGetInstanceSettingRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstanceSettingRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstanceSettingRequest',
    as HashRef[GetInstanceSettingRequest()];

declare 'GetInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstanceTemplateRequest'];

coerce 'GetInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstanceTemplateRequest'->new($_) };

declare 'RepeatedGetInstanceTemplateRequest',
    as ArrayRef[GetInstanceTemplateRequest()];

coerce 'RepeatedGetInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstanceTemplateRequest',
    as HashRef[GetInstanceTemplateRequest()];

declare 'GetInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstantSnapshotGroupRequest'];

coerce 'GetInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedGetInstantSnapshotGroupRequest',
    as ArrayRef[GetInstantSnapshotGroupRequest()];

coerce 'RepeatedGetInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstantSnapshotGroupRequest',
    as HashRef[GetInstantSnapshotGroupRequest()];

declare 'GetInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInstantSnapshotRequest'];

coerce 'GetInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInstantSnapshotRequest'->new($_) };

declare 'RepeatedGetInstantSnapshotRequest',
    as ArrayRef[GetInstantSnapshotRequest()];

coerce 'RepeatedGetInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetInstantSnapshotRequest',
    as HashRef[GetInstantSnapshotRequest()];

declare 'GetInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInterconnectAttachmentGroupRequest'];

coerce 'GetInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedGetInterconnectAttachmentGroupRequest',
    as ArrayRef[GetInterconnectAttachmentGroupRequest()];

coerce 'RepeatedGetInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetInterconnectAttachmentGroupRequest',
    as HashRef[GetInterconnectAttachmentGroupRequest()];

declare 'GetInterconnectAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInterconnectAttachmentRequest'];

coerce 'GetInterconnectAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInterconnectAttachmentRequest'->new($_) };

declare 'RepeatedGetInterconnectAttachmentRequest',
    as ArrayRef[GetInterconnectAttachmentRequest()];

coerce 'RepeatedGetInterconnectAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInterconnectAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringGetInterconnectAttachmentRequest',
    as HashRef[GetInterconnectAttachmentRequest()];

declare 'GetInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInterconnectGroupRequest'];

coerce 'GetInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInterconnectGroupRequest'->new($_) };

declare 'RepeatedGetInterconnectGroupRequest',
    as ArrayRef[GetInterconnectGroupRequest()];

coerce 'RepeatedGetInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetInterconnectGroupRequest',
    as HashRef[GetInterconnectGroupRequest()];

declare 'GetInterconnectLocationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInterconnectLocationRequest'];

coerce 'GetInterconnectLocationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInterconnectLocationRequest'->new($_) };

declare 'RepeatedGetInterconnectLocationRequest',
    as ArrayRef[GetInterconnectLocationRequest()];

coerce 'RepeatedGetInterconnectLocationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInterconnectLocationRequest'->new($_) } @$_ ] };

declare 'MapStringGetInterconnectLocationRequest',
    as HashRef[GetInterconnectLocationRequest()];

declare 'GetInterconnectRemoteLocationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInterconnectRemoteLocationRequest'];

coerce 'GetInterconnectRemoteLocationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInterconnectRemoteLocationRequest'->new($_) };

declare 'RepeatedGetInterconnectRemoteLocationRequest',
    as ArrayRef[GetInterconnectRemoteLocationRequest()];

coerce 'RepeatedGetInterconnectRemoteLocationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInterconnectRemoteLocationRequest'->new($_) } @$_ ] };

declare 'MapStringGetInterconnectRemoteLocationRequest',
    as HashRef[GetInterconnectRemoteLocationRequest()];

declare 'GetInterconnectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetInterconnectRequest'];

coerce 'GetInterconnectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetInterconnectRequest'->new($_) };

declare 'RepeatedGetInterconnectRequest',
    as ArrayRef[GetInterconnectRequest()];

coerce 'RepeatedGetInterconnectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetInterconnectRequest'->new($_) } @$_ ] };

declare 'MapStringGetInterconnectRequest',
    as HashRef[GetInterconnectRequest()];

declare 'GetLicenseCodeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetLicenseCodeRequest'];

coerce 'GetLicenseCodeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetLicenseCodeRequest'->new($_) };

declare 'RepeatedGetLicenseCodeRequest',
    as ArrayRef[GetLicenseCodeRequest()];

coerce 'RepeatedGetLicenseCodeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetLicenseCodeRequest'->new($_) } @$_ ] };

declare 'MapStringGetLicenseCodeRequest',
    as HashRef[GetLicenseCodeRequest()];

declare 'GetLicenseRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetLicenseRequest'];

coerce 'GetLicenseRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetLicenseRequest'->new($_) };

declare 'RepeatedGetLicenseRequest',
    as ArrayRef[GetLicenseRequest()];

coerce 'RepeatedGetLicenseRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetLicenseRequest'->new($_) } @$_ ] };

declare 'MapStringGetLicenseRequest',
    as HashRef[GetLicenseRequest()];

declare 'GetMachineImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetMachineImageRequest'];

coerce 'GetMachineImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetMachineImageRequest'->new($_) };

declare 'RepeatedGetMachineImageRequest',
    as ArrayRef[GetMachineImageRequest()];

coerce 'RepeatedGetMachineImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetMachineImageRequest'->new($_) } @$_ ] };

declare 'MapStringGetMachineImageRequest',
    as HashRef[GetMachineImageRequest()];

declare 'GetMachineTypeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetMachineTypeRequest'];

coerce 'GetMachineTypeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetMachineTypeRequest'->new($_) };

declare 'RepeatedGetMachineTypeRequest',
    as ArrayRef[GetMachineTypeRequest()];

coerce 'RepeatedGetMachineTypeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetMachineTypeRequest'->new($_) } @$_ ] };

declare 'MapStringGetMachineTypeRequest',
    as HashRef[GetMachineTypeRequest()];

declare 'GetMacsecConfigInterconnectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetMacsecConfigInterconnectRequest'];

coerce 'GetMacsecConfigInterconnectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetMacsecConfigInterconnectRequest'->new($_) };

declare 'RepeatedGetMacsecConfigInterconnectRequest',
    as ArrayRef[GetMacsecConfigInterconnectRequest()];

coerce 'RepeatedGetMacsecConfigInterconnectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetMacsecConfigInterconnectRequest'->new($_) } @$_ ] };

declare 'MapStringGetMacsecConfigInterconnectRequest',
    as HashRef[GetMacsecConfigInterconnectRequest()];

declare 'GetNamedSetRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNamedSetRouterRequest'];

coerce 'GetNamedSetRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNamedSetRouterRequest'->new($_) };

declare 'RepeatedGetNamedSetRouterRequest',
    as ArrayRef[GetNamedSetRouterRequest()];

coerce 'RepeatedGetNamedSetRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNamedSetRouterRequest'->new($_) } @$_ ] };

declare 'MapStringGetNamedSetRouterRequest',
    as HashRef[GetNamedSetRouterRequest()];

declare 'GetNatIpInfoRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNatIpInfoRouterRequest'];

coerce 'GetNatIpInfoRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNatIpInfoRouterRequest'->new($_) };

declare 'RepeatedGetNatIpInfoRouterRequest',
    as ArrayRef[GetNatIpInfoRouterRequest()];

coerce 'RepeatedGetNatIpInfoRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNatIpInfoRouterRequest'->new($_) } @$_ ] };

declare 'MapStringGetNatIpInfoRouterRequest',
    as HashRef[GetNatIpInfoRouterRequest()];

declare 'GetNatMappingInfoRoutersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNatMappingInfoRoutersRequest'];

coerce 'GetNatMappingInfoRoutersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNatMappingInfoRoutersRequest'->new($_) };

declare 'RepeatedGetNatMappingInfoRoutersRequest',
    as ArrayRef[GetNatMappingInfoRoutersRequest()];

coerce 'RepeatedGetNatMappingInfoRoutersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNatMappingInfoRoutersRequest'->new($_) } @$_ ] };

declare 'MapStringGetNatMappingInfoRoutersRequest',
    as HashRef[GetNatMappingInfoRoutersRequest()];

declare 'GetNetworkAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNetworkAttachmentRequest'];

coerce 'GetNetworkAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNetworkAttachmentRequest'->new($_) };

declare 'RepeatedGetNetworkAttachmentRequest',
    as ArrayRef[GetNetworkAttachmentRequest()];

coerce 'RepeatedGetNetworkAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNetworkAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringGetNetworkAttachmentRequest',
    as HashRef[GetNetworkAttachmentRequest()];

declare 'GetNetworkEdgeSecurityServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNetworkEdgeSecurityServiceRequest'];

coerce 'GetNetworkEdgeSecurityServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNetworkEdgeSecurityServiceRequest'->new($_) };

declare 'RepeatedGetNetworkEdgeSecurityServiceRequest',
    as ArrayRef[GetNetworkEdgeSecurityServiceRequest()];

coerce 'RepeatedGetNetworkEdgeSecurityServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNetworkEdgeSecurityServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetNetworkEdgeSecurityServiceRequest',
    as HashRef[GetNetworkEdgeSecurityServiceRequest()];

declare 'GetNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNetworkEndpointGroupRequest'];

coerce 'GetNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedGetNetworkEndpointGroupRequest',
    as ArrayRef[GetNetworkEndpointGroupRequest()];

coerce 'RepeatedGetNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetNetworkEndpointGroupRequest',
    as HashRef[GetNetworkEndpointGroupRequest()];

declare 'GetNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNetworkFirewallPolicyRequest'];

coerce 'GetNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetNetworkFirewallPolicyRequest',
    as ArrayRef[GetNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetNetworkFirewallPolicyRequest',
    as HashRef[GetNetworkFirewallPolicyRequest()];

declare 'GetNetworkProfileRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNetworkProfileRequest'];

coerce 'GetNetworkProfileRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNetworkProfileRequest'->new($_) };

declare 'RepeatedGetNetworkProfileRequest',
    as ArrayRef[GetNetworkProfileRequest()];

coerce 'RepeatedGetNetworkProfileRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNetworkProfileRequest'->new($_) } @$_ ] };

declare 'MapStringGetNetworkProfileRequest',
    as HashRef[GetNetworkProfileRequest()];

declare 'GetNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNetworkRequest'];

coerce 'GetNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNetworkRequest'->new($_) };

declare 'RepeatedGetNetworkRequest',
    as ArrayRef[GetNetworkRequest()];

coerce 'RepeatedGetNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringGetNetworkRequest',
    as HashRef[GetNetworkRequest()];

declare 'GetNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNodeGroupRequest'];

coerce 'GetNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNodeGroupRequest'->new($_) };

declare 'RepeatedGetNodeGroupRequest',
    as ArrayRef[GetNodeGroupRequest()];

coerce 'RepeatedGetNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetNodeGroupRequest',
    as HashRef[GetNodeGroupRequest()];

declare 'GetNodeTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNodeTemplateRequest'];

coerce 'GetNodeTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNodeTemplateRequest'->new($_) };

declare 'RepeatedGetNodeTemplateRequest',
    as ArrayRef[GetNodeTemplateRequest()];

coerce 'RepeatedGetNodeTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNodeTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringGetNodeTemplateRequest',
    as HashRef[GetNodeTemplateRequest()];

declare 'GetNodeTypeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetNodeTypeRequest'];

coerce 'GetNodeTypeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetNodeTypeRequest'->new($_) };

declare 'RepeatedGetNodeTypeRequest',
    as ArrayRef[GetNodeTypeRequest()];

coerce 'RepeatedGetNodeTypeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetNodeTypeRequest'->new($_) } @$_ ] };

declare 'MapStringGetNodeTypeRequest',
    as HashRef[GetNodeTypeRequest()];

declare 'GetOperationalStatusInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetOperationalStatusInterconnectAttachmentGroupRequest'];

coerce 'GetOperationalStatusInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetOperationalStatusInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedGetOperationalStatusInterconnectAttachmentGroupRequest',
    as ArrayRef[GetOperationalStatusInterconnectAttachmentGroupRequest()];

coerce 'RepeatedGetOperationalStatusInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetOperationalStatusInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetOperationalStatusInterconnectAttachmentGroupRequest',
    as HashRef[GetOperationalStatusInterconnectAttachmentGroupRequest()];

declare 'GetOperationalStatusInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetOperationalStatusInterconnectGroupRequest'];

coerce 'GetOperationalStatusInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetOperationalStatusInterconnectGroupRequest'->new($_) };

declare 'RepeatedGetOperationalStatusInterconnectGroupRequest',
    as ArrayRef[GetOperationalStatusInterconnectGroupRequest()];

coerce 'RepeatedGetOperationalStatusInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetOperationalStatusInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetOperationalStatusInterconnectGroupRequest',
    as HashRef[GetOperationalStatusInterconnectGroupRequest()];

declare 'GetOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetOrganizationSecurityPolicyRequest'];

coerce 'GetOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedGetOrganizationSecurityPolicyRequest',
    as ArrayRef[GetOrganizationSecurityPolicyRequest()];

coerce 'RepeatedGetOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetOrganizationSecurityPolicyRequest',
    as HashRef[GetOrganizationSecurityPolicyRequest()];

declare 'GetPacketMirroringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetPacketMirroringRequest'];

coerce 'GetPacketMirroringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetPacketMirroringRequest'->new($_) };

declare 'RepeatedGetPacketMirroringRequest',
    as ArrayRef[GetPacketMirroringRequest()];

coerce 'RepeatedGetPacketMirroringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetPacketMirroringRequest'->new($_) } @$_ ] };

declare 'MapStringGetPacketMirroringRequest',
    as HashRef[GetPacketMirroringRequest()];

declare 'GetPacketMirroringRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetPacketMirroringRuleNetworkFirewallPolicyRequest'];

coerce 'GetPacketMirroringRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetPacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetPacketMirroringRuleNetworkFirewallPolicyRequest',
    as ArrayRef[GetPacketMirroringRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetPacketMirroringRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetPacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetPacketMirroringRuleNetworkFirewallPolicyRequest',
    as HashRef[GetPacketMirroringRuleNetworkFirewallPolicyRequest()];

declare 'GetPreviewFeatureRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetPreviewFeatureRequest'];

coerce 'GetPreviewFeatureRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetPreviewFeatureRequest'->new($_) };

declare 'RepeatedGetPreviewFeatureRequest',
    as ArrayRef[GetPreviewFeatureRequest()];

coerce 'RepeatedGetPreviewFeatureRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetPreviewFeatureRequest'->new($_) } @$_ ] };

declare 'MapStringGetPreviewFeatureRequest',
    as HashRef[GetPreviewFeatureRequest()];

declare 'GetProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetProjectRequest'];

coerce 'GetProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetProjectRequest'->new($_) };

declare 'RepeatedGetProjectRequest',
    as ArrayRef[GetProjectRequest()];

coerce 'RepeatedGetProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetProjectRequest'->new($_) } @$_ ] };

declare 'MapStringGetProjectRequest',
    as HashRef[GetProjectRequest()];

declare 'GetPublicAdvertisedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetPublicAdvertisedPrefixeRequest'];

coerce 'GetPublicAdvertisedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetPublicAdvertisedPrefixeRequest'->new($_) };

declare 'RepeatedGetPublicAdvertisedPrefixeRequest',
    as ArrayRef[GetPublicAdvertisedPrefixeRequest()];

coerce 'RepeatedGetPublicAdvertisedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetPublicAdvertisedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringGetPublicAdvertisedPrefixeRequest',
    as HashRef[GetPublicAdvertisedPrefixeRequest()];

declare 'GetPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetPublicDelegatedPrefixeRequest'];

coerce 'GetPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedGetPublicDelegatedPrefixeRequest',
    as ArrayRef[GetPublicDelegatedPrefixeRequest()];

coerce 'RepeatedGetPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringGetPublicDelegatedPrefixeRequest',
    as HashRef[GetPublicDelegatedPrefixeRequest()];

declare 'GetRegionAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionAutoscalerRequest'];

coerce 'GetRegionAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionAutoscalerRequest'->new($_) };

declare 'RepeatedGetRegionAutoscalerRequest',
    as ArrayRef[GetRegionAutoscalerRequest()];

coerce 'RepeatedGetRegionAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionAutoscalerRequest',
    as HashRef[GetRegionAutoscalerRequest()];

declare 'GetRegionBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionBackendBucketRequest'];

coerce 'GetRegionBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionBackendBucketRequest'->new($_) };

declare 'RepeatedGetRegionBackendBucketRequest',
    as ArrayRef[GetRegionBackendBucketRequest()];

coerce 'RepeatedGetRegionBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionBackendBucketRequest',
    as HashRef[GetRegionBackendBucketRequest()];

declare 'GetRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionBackendServiceRequest'];

coerce 'GetRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionBackendServiceRequest'->new($_) };

declare 'RepeatedGetRegionBackendServiceRequest',
    as ArrayRef[GetRegionBackendServiceRequest()];

coerce 'RepeatedGetRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionBackendServiceRequest',
    as HashRef[GetRegionBackendServiceRequest()];

declare 'GetRegionCommitmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionCommitmentRequest'];

coerce 'GetRegionCommitmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionCommitmentRequest'->new($_) };

declare 'RepeatedGetRegionCommitmentRequest',
    as ArrayRef[GetRegionCommitmentRequest()];

coerce 'RepeatedGetRegionCommitmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionCommitmentRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionCommitmentRequest',
    as HashRef[GetRegionCommitmentRequest()];

declare 'GetRegionCompositeHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionCompositeHealthCheckRequest'];

coerce 'GetRegionCompositeHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionCompositeHealthCheckRequest'->new($_) };

declare 'RepeatedGetRegionCompositeHealthCheckRequest',
    as ArrayRef[GetRegionCompositeHealthCheckRequest()];

coerce 'RepeatedGetRegionCompositeHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionCompositeHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionCompositeHealthCheckRequest',
    as HashRef[GetRegionCompositeHealthCheckRequest()];

declare 'GetRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionDiskRequest'];

coerce 'GetRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionDiskRequest'->new($_) };

declare 'RepeatedGetRegionDiskRequest',
    as ArrayRef[GetRegionDiskRequest()];

coerce 'RepeatedGetRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionDiskRequest',
    as HashRef[GetRegionDiskRequest()];

declare 'GetRegionDiskTypeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionDiskTypeRequest'];

coerce 'GetRegionDiskTypeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionDiskTypeRequest'->new($_) };

declare 'RepeatedGetRegionDiskTypeRequest',
    as ArrayRef[GetRegionDiskTypeRequest()];

coerce 'RepeatedGetRegionDiskTypeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionDiskTypeRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionDiskTypeRequest',
    as HashRef[GetRegionDiskTypeRequest()];

declare 'GetRegionHealthAggregationPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionHealthAggregationPolicyRequest'];

coerce 'GetRegionHealthAggregationPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthAggregationPolicyRequest'->new($_) };

declare 'RepeatedGetRegionHealthAggregationPolicyRequest',
    as ArrayRef[GetRegionHealthAggregationPolicyRequest()];

coerce 'RepeatedGetRegionHealthAggregationPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthAggregationPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionHealthAggregationPolicyRequest',
    as HashRef[GetRegionHealthAggregationPolicyRequest()];

declare 'GetRegionHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionHealthCheckRequest'];

coerce 'GetRegionHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthCheckRequest'->new($_) };

declare 'RepeatedGetRegionHealthCheckRequest',
    as ArrayRef[GetRegionHealthCheckRequest()];

coerce 'RepeatedGetRegionHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionHealthCheckRequest',
    as HashRef[GetRegionHealthCheckRequest()];

declare 'GetRegionHealthCheckServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionHealthCheckServiceRequest'];

coerce 'GetRegionHealthCheckServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthCheckServiceRequest'->new($_) };

declare 'RepeatedGetRegionHealthCheckServiceRequest',
    as ArrayRef[GetRegionHealthCheckServiceRequest()];

coerce 'RepeatedGetRegionHealthCheckServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthCheckServiceRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionHealthCheckServiceRequest',
    as HashRef[GetRegionHealthCheckServiceRequest()];

declare 'GetRegionHealthSourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionHealthSourceRequest'];

coerce 'GetRegionHealthSourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthSourceRequest'->new($_) };

declare 'RepeatedGetRegionHealthSourceRequest',
    as ArrayRef[GetRegionHealthSourceRequest()];

coerce 'RepeatedGetRegionHealthSourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionHealthSourceRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionHealthSourceRequest',
    as HashRef[GetRegionHealthSourceRequest()];

declare 'GetRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupManagerRequest'];

coerce 'GetRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedGetRegionInstanceGroupManagerRequest',
    as ArrayRef[GetRegionInstanceGroupManagerRequest()];

coerce 'RepeatedGetRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionInstanceGroupManagerRequest',
    as HashRef[GetRegionInstanceGroupManagerRequest()];

declare 'GetRegionInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupManagerResizeRequestRequest'];

coerce 'GetRegionInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedGetRegionInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[GetRegionInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedGetRegionInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionInstanceGroupManagerResizeRequestRequest',
    as HashRef[GetRegionInstanceGroupManagerResizeRequestRequest()];

declare 'GetRegionInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupRequest'];

coerce 'GetRegionInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupRequest'->new($_) };

declare 'RepeatedGetRegionInstanceGroupRequest',
    as ArrayRef[GetRegionInstanceGroupRequest()];

coerce 'RepeatedGetRegionInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionInstanceGroupRequest',
    as HashRef[GetRegionInstanceGroupRequest()];

declare 'GetRegionInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionInstanceTemplateRequest'];

coerce 'GetRegionInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceTemplateRequest'->new($_) };

declare 'RepeatedGetRegionInstanceTemplateRequest',
    as ArrayRef[GetRegionInstanceTemplateRequest()];

coerce 'RepeatedGetRegionInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionInstanceTemplateRequest',
    as HashRef[GetRegionInstanceTemplateRequest()];

declare 'GetRegionInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionInstantSnapshotGroupRequest'];

coerce 'GetRegionInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedGetRegionInstantSnapshotGroupRequest',
    as ArrayRef[GetRegionInstantSnapshotGroupRequest()];

coerce 'RepeatedGetRegionInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionInstantSnapshotGroupRequest',
    as HashRef[GetRegionInstantSnapshotGroupRequest()];

declare 'GetRegionInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionInstantSnapshotRequest'];

coerce 'GetRegionInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionInstantSnapshotRequest'->new($_) };

declare 'RepeatedGetRegionInstantSnapshotRequest',
    as ArrayRef[GetRegionInstantSnapshotRequest()];

coerce 'RepeatedGetRegionInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionInstantSnapshotRequest',
    as HashRef[GetRegionInstantSnapshotRequest()];

declare 'GetRegionNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionNetworkEndpointGroupRequest'];

coerce 'GetRegionNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedGetRegionNetworkEndpointGroupRequest',
    as ArrayRef[GetRegionNetworkEndpointGroupRequest()];

coerce 'RepeatedGetRegionNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionNetworkEndpointGroupRequest',
    as HashRef[GetRegionNetworkEndpointGroupRequest()];

declare 'GetRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionNetworkFirewallPolicyRequest'];

coerce 'GetRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetRegionNetworkFirewallPolicyRequest',
    as ArrayRef[GetRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionNetworkFirewallPolicyRequest',
    as HashRef[GetRegionNetworkFirewallPolicyRequest()];

declare 'GetRegionNotificationEndpointRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionNotificationEndpointRequest'];

coerce 'GetRegionNotificationEndpointRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionNotificationEndpointRequest'->new($_) };

declare 'RepeatedGetRegionNotificationEndpointRequest',
    as ArrayRef[GetRegionNotificationEndpointRequest()];

coerce 'RepeatedGetRegionNotificationEndpointRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionNotificationEndpointRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionNotificationEndpointRequest',
    as HashRef[GetRegionNotificationEndpointRequest()];

declare 'GetRegionOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionOperationRequest'];

coerce 'GetRegionOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionOperationRequest'->new($_) };

declare 'RepeatedGetRegionOperationRequest',
    as ArrayRef[GetRegionOperationRequest()];

coerce 'RepeatedGetRegionOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionOperationRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionOperationRequest',
    as HashRef[GetRegionOperationRequest()];

declare 'GetRegionRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionRequest'];

coerce 'GetRegionRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionRequest'->new($_) };

declare 'RepeatedGetRegionRequest',
    as ArrayRef[GetRegionRequest()];

coerce 'RepeatedGetRegionRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionRequest',
    as HashRef[GetRegionRequest()];

declare 'GetRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionSecurityPolicyRequest'];

coerce 'GetRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedGetRegionSecurityPolicyRequest',
    as ArrayRef[GetRegionSecurityPolicyRequest()];

coerce 'RepeatedGetRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionSecurityPolicyRequest',
    as HashRef[GetRegionSecurityPolicyRequest()];

declare 'GetRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionSnapshotRequest'];

coerce 'GetRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionSnapshotRequest'->new($_) };

declare 'RepeatedGetRegionSnapshotRequest',
    as ArrayRef[GetRegionSnapshotRequest()];

coerce 'RepeatedGetRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionSnapshotRequest',
    as HashRef[GetRegionSnapshotRequest()];

declare 'GetRegionSnapshotSettingRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionSnapshotSettingRequest'];

coerce 'GetRegionSnapshotSettingRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionSnapshotSettingRequest'->new($_) };

declare 'RepeatedGetRegionSnapshotSettingRequest',
    as ArrayRef[GetRegionSnapshotSettingRequest()];

coerce 'RepeatedGetRegionSnapshotSettingRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionSnapshotSettingRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionSnapshotSettingRequest',
    as HashRef[GetRegionSnapshotSettingRequest()];

declare 'GetRegionSslCertificateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionSslCertificateRequest'];

coerce 'GetRegionSslCertificateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionSslCertificateRequest'->new($_) };

declare 'RepeatedGetRegionSslCertificateRequest',
    as ArrayRef[GetRegionSslCertificateRequest()];

coerce 'RepeatedGetRegionSslCertificateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionSslCertificateRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionSslCertificateRequest',
    as HashRef[GetRegionSslCertificateRequest()];

declare 'GetRegionSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionSslPolicyRequest'];

coerce 'GetRegionSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionSslPolicyRequest'->new($_) };

declare 'RepeatedGetRegionSslPolicyRequest',
    as ArrayRef[GetRegionSslPolicyRequest()];

coerce 'RepeatedGetRegionSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionSslPolicyRequest',
    as HashRef[GetRegionSslPolicyRequest()];

declare 'GetRegionTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionTargetHttpProxyRequest'];

coerce 'GetRegionTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionTargetHttpProxyRequest'->new($_) };

declare 'RepeatedGetRegionTargetHttpProxyRequest',
    as ArrayRef[GetRegionTargetHttpProxyRequest()];

coerce 'RepeatedGetRegionTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionTargetHttpProxyRequest',
    as HashRef[GetRegionTargetHttpProxyRequest()];

declare 'GetRegionTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionTargetHttpsProxyRequest'];

coerce 'GetRegionTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedGetRegionTargetHttpsProxyRequest',
    as ArrayRef[GetRegionTargetHttpsProxyRequest()];

coerce 'RepeatedGetRegionTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionTargetHttpsProxyRequest',
    as HashRef[GetRegionTargetHttpsProxyRequest()];

declare 'GetRegionTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionTargetTcpProxyRequest'];

coerce 'GetRegionTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionTargetTcpProxyRequest'->new($_) };

declare 'RepeatedGetRegionTargetTcpProxyRequest',
    as ArrayRef[GetRegionTargetTcpProxyRequest()];

coerce 'RepeatedGetRegionTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionTargetTcpProxyRequest',
    as HashRef[GetRegionTargetTcpProxyRequest()];

declare 'GetRegionUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRegionUrlMapRequest'];

coerce 'GetRegionUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRegionUrlMapRequest'->new($_) };

declare 'RepeatedGetRegionUrlMapRequest',
    as ArrayRef[GetRegionUrlMapRequest()];

coerce 'RepeatedGetRegionUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRegionUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringGetRegionUrlMapRequest',
    as HashRef[GetRegionUrlMapRequest()];

declare 'GetReservationBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetReservationBlockRequest'];

coerce 'GetReservationBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetReservationBlockRequest'->new($_) };

declare 'RepeatedGetReservationBlockRequest',
    as ArrayRef[GetReservationBlockRequest()];

coerce 'RepeatedGetReservationBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetReservationBlockRequest'->new($_) } @$_ ] };

declare 'MapStringGetReservationBlockRequest',
    as HashRef[GetReservationBlockRequest()];

declare 'View',
    as (Int | Str);

declare 'GetReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetReservationRequest'];

coerce 'GetReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetReservationRequest'->new($_) };

declare 'RepeatedGetReservationRequest',
    as ArrayRef[GetReservationRequest()];

coerce 'RepeatedGetReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetReservationRequest'->new($_) } @$_ ] };

declare 'MapStringGetReservationRequest',
    as HashRef[GetReservationRequest()];

declare 'GetReservationSlotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetReservationSlotRequest'];

coerce 'GetReservationSlotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetReservationSlotRequest'->new($_) };

declare 'RepeatedGetReservationSlotRequest',
    as ArrayRef[GetReservationSlotRequest()];

coerce 'RepeatedGetReservationSlotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetReservationSlotRequest'->new($_) } @$_ ] };

declare 'MapStringGetReservationSlotRequest',
    as HashRef[GetReservationSlotRequest()];

declare 'GetReservationSubBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetReservationSubBlockRequest'];

coerce 'GetReservationSubBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetReservationSubBlockRequest'->new($_) };

declare 'RepeatedGetReservationSubBlockRequest',
    as ArrayRef[GetReservationSubBlockRequest()];

coerce 'RepeatedGetReservationSubBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetReservationSubBlockRequest'->new($_) } @$_ ] };

declare 'MapStringGetReservationSubBlockRequest',
    as HashRef[GetReservationSubBlockRequest()];

declare 'View',
    as (Int | Str);

declare 'GetResourcePolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetResourcePolicyRequest'];

coerce 'GetResourcePolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetResourcePolicyRequest'->new($_) };

declare 'RepeatedGetResourcePolicyRequest',
    as ArrayRef[GetResourcePolicyRequest()];

coerce 'RepeatedGetResourcePolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetResourcePolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetResourcePolicyRequest',
    as HashRef[GetResourcePolicyRequest()];

declare 'GetRolloutPlanRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRolloutPlanRequest'];

coerce 'GetRolloutPlanRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRolloutPlanRequest'->new($_) };

declare 'RepeatedGetRolloutPlanRequest',
    as ArrayRef[GetRolloutPlanRequest()];

coerce 'RepeatedGetRolloutPlanRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRolloutPlanRequest'->new($_) } @$_ ] };

declare 'MapStringGetRolloutPlanRequest',
    as HashRef[GetRolloutPlanRequest()];

declare 'GetRolloutRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRolloutRequest'];

coerce 'GetRolloutRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRolloutRequest'->new($_) };

declare 'RepeatedGetRolloutRequest',
    as ArrayRef[GetRolloutRequest()];

coerce 'RepeatedGetRolloutRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRolloutRequest'->new($_) } @$_ ] };

declare 'MapStringGetRolloutRequest',
    as HashRef[GetRolloutRequest()];

declare 'GetRoutePolicyRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRoutePolicyRouterRequest'];

coerce 'GetRoutePolicyRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRoutePolicyRouterRequest'->new($_) };

declare 'RepeatedGetRoutePolicyRouterRequest',
    as ArrayRef[GetRoutePolicyRouterRequest()];

coerce 'RepeatedGetRoutePolicyRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRoutePolicyRouterRequest'->new($_) } @$_ ] };

declare 'MapStringGetRoutePolicyRouterRequest',
    as HashRef[GetRoutePolicyRouterRequest()];

declare 'GetRouteRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRouteRequest'];

coerce 'GetRouteRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRouteRequest'->new($_) };

declare 'RepeatedGetRouteRequest',
    as ArrayRef[GetRouteRequest()];

coerce 'RepeatedGetRouteRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRouteRequest'->new($_) } @$_ ] };

declare 'MapStringGetRouteRequest',
    as HashRef[GetRouteRequest()];

declare 'GetRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRouterRequest'];

coerce 'GetRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRouterRequest'->new($_) };

declare 'RepeatedGetRouterRequest',
    as ArrayRef[GetRouterRequest()];

coerce 'RepeatedGetRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRouterRequest'->new($_) } @$_ ] };

declare 'MapStringGetRouterRequest',
    as HashRef[GetRouterRequest()];

declare 'GetRouterStatusRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRouterStatusRouterRequest'];

coerce 'GetRouterStatusRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRouterStatusRouterRequest'->new($_) };

declare 'RepeatedGetRouterStatusRouterRequest',
    as ArrayRef[GetRouterStatusRouterRequest()];

coerce 'RepeatedGetRouterStatusRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRouterStatusRouterRequest'->new($_) } @$_ ] };

declare 'MapStringGetRouterStatusRouterRequest',
    as HashRef[GetRouterStatusRouterRequest()];

declare 'GetRuleFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRuleFirewallPolicyRequest'];

coerce 'GetRuleFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRuleFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetRuleFirewallPolicyRequest',
    as ArrayRef[GetRuleFirewallPolicyRequest()];

coerce 'RepeatedGetRuleFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRuleFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRuleFirewallPolicyRequest',
    as HashRef[GetRuleFirewallPolicyRequest()];

declare 'GetRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRuleNetworkFirewallPolicyRequest'];

coerce 'GetRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetRuleNetworkFirewallPolicyRequest',
    as ArrayRef[GetRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRuleNetworkFirewallPolicyRequest',
    as HashRef[GetRuleNetworkFirewallPolicyRequest()];

declare 'GetRuleOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRuleOrganizationSecurityPolicyRequest'];

coerce 'GetRuleOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRuleOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedGetRuleOrganizationSecurityPolicyRequest',
    as ArrayRef[GetRuleOrganizationSecurityPolicyRequest()];

coerce 'RepeatedGetRuleOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRuleOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRuleOrganizationSecurityPolicyRequest',
    as HashRef[GetRuleOrganizationSecurityPolicyRequest()];

declare 'GetRuleRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRuleRegionNetworkFirewallPolicyRequest'];

coerce 'GetRuleRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRuleRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedGetRuleRegionNetworkFirewallPolicyRequest',
    as ArrayRef[GetRuleRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedGetRuleRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRuleRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRuleRegionNetworkFirewallPolicyRequest',
    as HashRef[GetRuleRegionNetworkFirewallPolicyRequest()];

declare 'GetRuleRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRuleRegionSecurityPolicyRequest'];

coerce 'GetRuleRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRuleRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedGetRuleRegionSecurityPolicyRequest',
    as ArrayRef[GetRuleRegionSecurityPolicyRequest()];

coerce 'RepeatedGetRuleRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRuleRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRuleRegionSecurityPolicyRequest',
    as HashRef[GetRuleRegionSecurityPolicyRequest()];

declare 'GetRuleSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetRuleSecurityPolicyRequest'];

coerce 'GetRuleSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetRuleSecurityPolicyRequest'->new($_) };

declare 'RepeatedGetRuleSecurityPolicyRequest',
    as ArrayRef[GetRuleSecurityPolicyRequest()];

coerce 'RepeatedGetRuleSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetRuleSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetRuleSecurityPolicyRequest',
    as HashRef[GetRuleSecurityPolicyRequest()];

declare 'GetScreenshotInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetScreenshotInstanceRequest'];

coerce 'GetScreenshotInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetScreenshotInstanceRequest'->new($_) };

declare 'RepeatedGetScreenshotInstanceRequest',
    as ArrayRef[GetScreenshotInstanceRequest()];

coerce 'RepeatedGetScreenshotInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetScreenshotInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetScreenshotInstanceRequest',
    as HashRef[GetScreenshotInstanceRequest()];

declare 'GetSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetSecurityPolicyRequest'];

coerce 'GetSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetSecurityPolicyRequest'->new($_) };

declare 'RepeatedGetSecurityPolicyRequest',
    as ArrayRef[GetSecurityPolicyRequest()];

coerce 'RepeatedGetSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetSecurityPolicyRequest',
    as HashRef[GetSecurityPolicyRequest()];

declare 'GetSerialPortOutputInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetSerialPortOutputInstanceRequest'];

coerce 'GetSerialPortOutputInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetSerialPortOutputInstanceRequest'->new($_) };

declare 'RepeatedGetSerialPortOutputInstanceRequest',
    as ArrayRef[GetSerialPortOutputInstanceRequest()];

coerce 'RepeatedGetSerialPortOutputInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetSerialPortOutputInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetSerialPortOutputInstanceRequest',
    as HashRef[GetSerialPortOutputInstanceRequest()];

declare 'GetServiceAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetServiceAttachmentRequest'];

coerce 'GetServiceAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetServiceAttachmentRequest'->new($_) };

declare 'RepeatedGetServiceAttachmentRequest',
    as ArrayRef[GetServiceAttachmentRequest()];

coerce 'RepeatedGetServiceAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetServiceAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringGetServiceAttachmentRequest',
    as HashRef[GetServiceAttachmentRequest()];

declare 'GetShieldedInstanceIdentityInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetShieldedInstanceIdentityInstanceRequest'];

coerce 'GetShieldedInstanceIdentityInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetShieldedInstanceIdentityInstanceRequest'->new($_) };

declare 'RepeatedGetShieldedInstanceIdentityInstanceRequest',
    as ArrayRef[GetShieldedInstanceIdentityInstanceRequest()];

coerce 'RepeatedGetShieldedInstanceIdentityInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetShieldedInstanceIdentityInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetShieldedInstanceIdentityInstanceRequest',
    as HashRef[GetShieldedInstanceIdentityInstanceRequest()];

declare 'GetSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetSnapshotRequest'];

coerce 'GetSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetSnapshotRequest'->new($_) };

declare 'RepeatedGetSnapshotRequest',
    as ArrayRef[GetSnapshotRequest()];

coerce 'RepeatedGetSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringGetSnapshotRequest',
    as HashRef[GetSnapshotRequest()];

declare 'GetSnapshotSettingRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetSnapshotSettingRequest'];

coerce 'GetSnapshotSettingRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetSnapshotSettingRequest'->new($_) };

declare 'RepeatedGetSnapshotSettingRequest',
    as ArrayRef[GetSnapshotSettingRequest()];

coerce 'RepeatedGetSnapshotSettingRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetSnapshotSettingRequest'->new($_) } @$_ ] };

declare 'MapStringGetSnapshotSettingRequest',
    as HashRef[GetSnapshotSettingRequest()];

declare 'GetSslCertificateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetSslCertificateRequest'];

coerce 'GetSslCertificateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetSslCertificateRequest'->new($_) };

declare 'RepeatedGetSslCertificateRequest',
    as ArrayRef[GetSslCertificateRequest()];

coerce 'RepeatedGetSslCertificateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetSslCertificateRequest'->new($_) } @$_ ] };

declare 'MapStringGetSslCertificateRequest',
    as HashRef[GetSslCertificateRequest()];

declare 'GetSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetSslPolicyRequest'];

coerce 'GetSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetSslPolicyRequest'->new($_) };

declare 'RepeatedGetSslPolicyRequest',
    as ArrayRef[GetSslPolicyRequest()];

coerce 'RepeatedGetSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetSslPolicyRequest',
    as HashRef[GetSslPolicyRequest()];

declare 'GetStatusVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetStatusVpnGatewayRequest'];

coerce 'GetStatusVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetStatusVpnGatewayRequest'->new($_) };

declare 'RepeatedGetStatusVpnGatewayRequest',
    as ArrayRef[GetStatusVpnGatewayRequest()];

coerce 'RepeatedGetStatusVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetStatusVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringGetStatusVpnGatewayRequest',
    as HashRef[GetStatusVpnGatewayRequest()];

declare 'GetStoragePoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetStoragePoolRequest'];

coerce 'GetStoragePoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetStoragePoolRequest'->new($_) };

declare 'RepeatedGetStoragePoolRequest',
    as ArrayRef[GetStoragePoolRequest()];

coerce 'RepeatedGetStoragePoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetStoragePoolRequest'->new($_) } @$_ ] };

declare 'MapStringGetStoragePoolRequest',
    as HashRef[GetStoragePoolRequest()];

declare 'GetStoragePoolTypeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetStoragePoolTypeRequest'];

coerce 'GetStoragePoolTypeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetStoragePoolTypeRequest'->new($_) };

declare 'RepeatedGetStoragePoolTypeRequest',
    as ArrayRef[GetStoragePoolTypeRequest()];

coerce 'RepeatedGetStoragePoolTypeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetStoragePoolTypeRequest'->new($_) } @$_ ] };

declare 'MapStringGetStoragePoolTypeRequest',
    as HashRef[GetStoragePoolTypeRequest()];

declare 'GetSubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetSubnetworkRequest'];

coerce 'GetSubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetSubnetworkRequest'->new($_) };

declare 'RepeatedGetSubnetworkRequest',
    as ArrayRef[GetSubnetworkRequest()];

coerce 'RepeatedGetSubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetSubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringGetSubnetworkRequest',
    as HashRef[GetSubnetworkRequest()];

declare 'Views',
    as (Int | Str);

declare 'GetTargetGrpcProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetGrpcProxyRequest'];

coerce 'GetTargetGrpcProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetGrpcProxyRequest'->new($_) };

declare 'RepeatedGetTargetGrpcProxyRequest',
    as ArrayRef[GetTargetGrpcProxyRequest()];

coerce 'RepeatedGetTargetGrpcProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetGrpcProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetGrpcProxyRequest',
    as HashRef[GetTargetGrpcProxyRequest()];

declare 'GetTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetHttpProxyRequest'];

coerce 'GetTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetHttpProxyRequest'->new($_) };

declare 'RepeatedGetTargetHttpProxyRequest',
    as ArrayRef[GetTargetHttpProxyRequest()];

coerce 'RepeatedGetTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetHttpProxyRequest',
    as HashRef[GetTargetHttpProxyRequest()];

declare 'GetTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetHttpsProxyRequest'];

coerce 'GetTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedGetTargetHttpsProxyRequest',
    as ArrayRef[GetTargetHttpsProxyRequest()];

coerce 'RepeatedGetTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetHttpsProxyRequest',
    as HashRef[GetTargetHttpsProxyRequest()];

declare 'GetTargetInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetInstanceRequest'];

coerce 'GetTargetInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetInstanceRequest'->new($_) };

declare 'RepeatedGetTargetInstanceRequest',
    as ArrayRef[GetTargetInstanceRequest()];

coerce 'RepeatedGetTargetInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetInstanceRequest',
    as HashRef[GetTargetInstanceRequest()];

declare 'GetTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetPoolRequest'];

coerce 'GetTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetPoolRequest'->new($_) };

declare 'RepeatedGetTargetPoolRequest',
    as ArrayRef[GetTargetPoolRequest()];

coerce 'RepeatedGetTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetPoolRequest',
    as HashRef[GetTargetPoolRequest()];

declare 'GetTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetSslProxyRequest'];

coerce 'GetTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetSslProxyRequest'->new($_) };

declare 'RepeatedGetTargetSslProxyRequest',
    as ArrayRef[GetTargetSslProxyRequest()];

coerce 'RepeatedGetTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetSslProxyRequest',
    as HashRef[GetTargetSslProxyRequest()];

declare 'GetTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetTcpProxyRequest'];

coerce 'GetTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetTcpProxyRequest'->new($_) };

declare 'RepeatedGetTargetTcpProxyRequest',
    as ArrayRef[GetTargetTcpProxyRequest()];

coerce 'RepeatedGetTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetTcpProxyRequest',
    as HashRef[GetTargetTcpProxyRequest()];

declare 'GetTargetVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetTargetVpnGatewayRequest'];

coerce 'GetTargetVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetTargetVpnGatewayRequest'->new($_) };

declare 'RepeatedGetTargetVpnGatewayRequest',
    as ArrayRef[GetTargetVpnGatewayRequest()];

coerce 'RepeatedGetTargetVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetTargetVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringGetTargetVpnGatewayRequest',
    as HashRef[GetTargetVpnGatewayRequest()];

declare 'GetUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetUrlMapRequest'];

coerce 'GetUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetUrlMapRequest'->new($_) };

declare 'RepeatedGetUrlMapRequest',
    as ArrayRef[GetUrlMapRequest()];

coerce 'RepeatedGetUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringGetUrlMapRequest',
    as HashRef[GetUrlMapRequest()];

declare 'GetVersionOperationMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadata'];

coerce 'GetVersionOperationMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadata'->new($_) };

declare 'RepeatedGetVersionOperationMetadata',
    as ArrayRef[GetVersionOperationMetadata()];

coerce 'RepeatedGetVersionOperationMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadata'->new($_) } @$_ ] };

declare 'MapStringGetVersionOperationMetadata',
    as HashRef[GetVersionOperationMetadata()];

declare 'GetVersionOperationMetadataSbomInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo'];

coerce 'GetVersionOperationMetadataSbomInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo'->new($_) };

declare 'RepeatedGetVersionOperationMetadataSbomInfo',
    as ArrayRef[GetVersionOperationMetadataSbomInfo()];

coerce 'RepeatedGetVersionOperationMetadataSbomInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo'->new($_) } @$_ ] };

declare 'MapStringGetVersionOperationMetadataSbomInfo',
    as HashRef[GetVersionOperationMetadataSbomInfo()];

declare 'CurrentComponentVersionsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo::CurrentComponentVersionsEntry'];

coerce 'CurrentComponentVersionsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo::CurrentComponentVersionsEntry'->new($_) };

declare 'RepeatedCurrentComponentVersionsEntry',
    as ArrayRef[CurrentComponentVersionsEntry()];

coerce 'RepeatedCurrentComponentVersionsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo::CurrentComponentVersionsEntry'->new($_) } @$_ ] };

declare 'MapStringCurrentComponentVersionsEntry',
    as HashRef[CurrentComponentVersionsEntry()];

declare 'TargetComponentVersionsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo::TargetComponentVersionsEntry'];

coerce 'TargetComponentVersionsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo::TargetComponentVersionsEntry'->new($_) };

declare 'RepeatedTargetComponentVersionsEntry',
    as ArrayRef[TargetComponentVersionsEntry()];

coerce 'RepeatedTargetComponentVersionsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVersionOperationMetadataSbomInfo::TargetComponentVersionsEntry'->new($_) } @$_ ] };

declare 'MapStringTargetComponentVersionsEntry',
    as HashRef[TargetComponentVersionsEntry()];

declare 'GetVersionReservationSlotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVersionReservationSlotRequest'];

coerce 'GetVersionReservationSlotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVersionReservationSlotRequest'->new($_) };

declare 'RepeatedGetVersionReservationSlotRequest',
    as ArrayRef[GetVersionReservationSlotRequest()];

coerce 'RepeatedGetVersionReservationSlotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVersionReservationSlotRequest'->new($_) } @$_ ] };

declare 'MapStringGetVersionReservationSlotRequest',
    as HashRef[GetVersionReservationSlotRequest()];

declare 'GetVersionReservationSubBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVersionReservationSubBlockRequest'];

coerce 'GetVersionReservationSubBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVersionReservationSubBlockRequest'->new($_) };

declare 'RepeatedGetVersionReservationSubBlockRequest',
    as ArrayRef[GetVersionReservationSubBlockRequest()];

coerce 'RepeatedGetVersionReservationSubBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVersionReservationSubBlockRequest'->new($_) } @$_ ] };

declare 'MapStringGetVersionReservationSubBlockRequest',
    as HashRef[GetVersionReservationSubBlockRequest()];

declare 'GetVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVpnGatewayRequest'];

coerce 'GetVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVpnGatewayRequest'->new($_) };

declare 'RepeatedGetVpnGatewayRequest',
    as ArrayRef[GetVpnGatewayRequest()];

coerce 'RepeatedGetVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringGetVpnGatewayRequest',
    as HashRef[GetVpnGatewayRequest()];

declare 'GetVpnTunnelRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetVpnTunnelRequest'];

coerce 'GetVpnTunnelRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetVpnTunnelRequest'->new($_) };

declare 'RepeatedGetVpnTunnelRequest',
    as ArrayRef[GetVpnTunnelRequest()];

coerce 'RepeatedGetVpnTunnelRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetVpnTunnelRequest'->new($_) } @$_ ] };

declare 'MapStringGetVpnTunnelRequest',
    as HashRef[GetVpnTunnelRequest()];

declare 'GetWireGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetWireGroupRequest'];

coerce 'GetWireGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetWireGroupRequest'->new($_) };

declare 'RepeatedGetWireGroupRequest',
    as ArrayRef[GetWireGroupRequest()];

coerce 'RepeatedGetWireGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetWireGroupRequest'->new($_) } @$_ ] };

declare 'MapStringGetWireGroupRequest',
    as HashRef[GetWireGroupRequest()];

declare 'GetXpnHostProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetXpnHostProjectRequest'];

coerce 'GetXpnHostProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetXpnHostProjectRequest'->new($_) };

declare 'RepeatedGetXpnHostProjectRequest',
    as ArrayRef[GetXpnHostProjectRequest()];

coerce 'RepeatedGetXpnHostProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetXpnHostProjectRequest'->new($_) } @$_ ] };

declare 'MapStringGetXpnHostProjectRequest',
    as HashRef[GetXpnHostProjectRequest()];

declare 'GetXpnResourcesProjectsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetXpnResourcesProjectsRequest'];

coerce 'GetXpnResourcesProjectsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetXpnResourcesProjectsRequest'->new($_) };

declare 'RepeatedGetXpnResourcesProjectsRequest',
    as ArrayRef[GetXpnResourcesProjectsRequest()];

coerce 'RepeatedGetXpnResourcesProjectsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetXpnResourcesProjectsRequest'->new($_) } @$_ ] };

declare 'MapStringGetXpnResourcesProjectsRequest',
    as HashRef[GetXpnResourcesProjectsRequest()];

declare 'GetZoneOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetZoneOperationRequest'];

coerce 'GetZoneOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetZoneOperationRequest'->new($_) };

declare 'RepeatedGetZoneOperationRequest',
    as ArrayRef[GetZoneOperationRequest()];

coerce 'RepeatedGetZoneOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetZoneOperationRequest'->new($_) } @$_ ] };

declare 'MapStringGetZoneOperationRequest',
    as HashRef[GetZoneOperationRequest()];

declare 'GetZoneRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetZoneRequest'];

coerce 'GetZoneRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetZoneRequest'->new($_) };

declare 'RepeatedGetZoneRequest',
    as ArrayRef[GetZoneRequest()];

coerce 'RepeatedGetZoneRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetZoneRequest'->new($_) } @$_ ] };

declare 'MapStringGetZoneRequest',
    as HashRef[GetZoneRequest()];

declare 'GetZoneVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GetZoneVmExtensionPolicyRequest'];

coerce 'GetZoneVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GetZoneVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedGetZoneVmExtensionPolicyRequest',
    as ArrayRef[GetZoneVmExtensionPolicyRequest()];

coerce 'RepeatedGetZoneVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GetZoneVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGetZoneVmExtensionPolicyRequest',
    as HashRef[GetZoneVmExtensionPolicyRequest()];

declare 'GlobalAddressesMoveRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalAddressesMoveRequest'];

coerce 'GlobalAddressesMoveRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalAddressesMoveRequest'->new($_) };

declare 'RepeatedGlobalAddressesMoveRequest',
    as ArrayRef[GlobalAddressesMoveRequest()];

coerce 'RepeatedGlobalAddressesMoveRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalAddressesMoveRequest'->new($_) } @$_ ] };

declare 'MapStringGlobalAddressesMoveRequest',
    as HashRef[GlobalAddressesMoveRequest()];

declare 'GlobalNetworkEndpointGroupsAttachEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalNetworkEndpointGroupsAttachEndpointsRequest'];

coerce 'GlobalNetworkEndpointGroupsAttachEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalNetworkEndpointGroupsAttachEndpointsRequest'->new($_) };

declare 'RepeatedGlobalNetworkEndpointGroupsAttachEndpointsRequest',
    as ArrayRef[GlobalNetworkEndpointGroupsAttachEndpointsRequest()];

coerce 'RepeatedGlobalNetworkEndpointGroupsAttachEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalNetworkEndpointGroupsAttachEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringGlobalNetworkEndpointGroupsAttachEndpointsRequest',
    as HashRef[GlobalNetworkEndpointGroupsAttachEndpointsRequest()];

declare 'GlobalNetworkEndpointGroupsDetachEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalNetworkEndpointGroupsDetachEndpointsRequest'];

coerce 'GlobalNetworkEndpointGroupsDetachEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalNetworkEndpointGroupsDetachEndpointsRequest'->new($_) };

declare 'RepeatedGlobalNetworkEndpointGroupsDetachEndpointsRequest',
    as ArrayRef[GlobalNetworkEndpointGroupsDetachEndpointsRequest()];

coerce 'RepeatedGlobalNetworkEndpointGroupsDetachEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalNetworkEndpointGroupsDetachEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringGlobalNetworkEndpointGroupsDetachEndpointsRequest',
    as HashRef[GlobalNetworkEndpointGroupsDetachEndpointsRequest()];

declare 'GlobalOrganizationSetPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalOrganizationSetPolicyRequest'];

coerce 'GlobalOrganizationSetPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalOrganizationSetPolicyRequest'->new($_) };

declare 'RepeatedGlobalOrganizationSetPolicyRequest',
    as ArrayRef[GlobalOrganizationSetPolicyRequest()];

coerce 'RepeatedGlobalOrganizationSetPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalOrganizationSetPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGlobalOrganizationSetPolicyRequest',
    as HashRef[GlobalOrganizationSetPolicyRequest()];

declare 'GlobalSetLabelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalSetLabelsRequest'];

coerce 'GlobalSetLabelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalSetLabelsRequest'->new($_) };

declare 'RepeatedGlobalSetLabelsRequest',
    as ArrayRef[GlobalSetLabelsRequest()];

coerce 'RepeatedGlobalSetLabelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalSetLabelsRequest'->new($_) } @$_ ] };

declare 'MapStringGlobalSetLabelsRequest',
    as HashRef[GlobalSetLabelsRequest()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalSetLabelsRequest::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalSetLabelsRequest::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalSetLabelsRequest::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'GlobalSetPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalSetPolicyRequest'];

coerce 'GlobalSetPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalSetPolicyRequest'->new($_) };

declare 'RepeatedGlobalSetPolicyRequest',
    as ArrayRef[GlobalSetPolicyRequest()];

coerce 'RepeatedGlobalSetPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalSetPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringGlobalSetPolicyRequest',
    as HashRef[GlobalSetPolicyRequest()];

declare 'GlobalVmExtensionPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicy'];

coerce 'GlobalVmExtensionPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicy'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicy',
    as ArrayRef[GlobalVmExtensionPolicy()];

coerce 'RepeatedGlobalVmExtensionPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicy'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicy',
    as HashRef[GlobalVmExtensionPolicy()];

declare 'ScopedResourceStatus',
    as (Int | Str);

declare 'ExtensionPoliciesEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicy::ExtensionPoliciesEntry'];

coerce 'ExtensionPoliciesEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicy::ExtensionPoliciesEntry'->new($_) };

declare 'RepeatedExtensionPoliciesEntry',
    as ArrayRef[ExtensionPoliciesEntry()];

coerce 'RepeatedExtensionPoliciesEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicy::ExtensionPoliciesEntry'->new($_) } @$_ ] };

declare 'MapStringExtensionPoliciesEntry',
    as HashRef[ExtensionPoliciesEntry()];

declare 'GlobalVmExtensionPolicyExtensionPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyExtensionPolicy'];

coerce 'GlobalVmExtensionPolicyExtensionPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyExtensionPolicy'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyExtensionPolicy',
    as ArrayRef[GlobalVmExtensionPolicyExtensionPolicy()];

coerce 'RepeatedGlobalVmExtensionPolicyExtensionPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyExtensionPolicy'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyExtensionPolicy',
    as HashRef[GlobalVmExtensionPolicyExtensionPolicy()];

declare 'GlobalVmExtensionPolicyInstanceSelector',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyInstanceSelector'];

coerce 'GlobalVmExtensionPolicyInstanceSelector',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyInstanceSelector'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyInstanceSelector',
    as ArrayRef[GlobalVmExtensionPolicyInstanceSelector()];

coerce 'RepeatedGlobalVmExtensionPolicyInstanceSelector',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyInstanceSelector'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyInstanceSelector',
    as HashRef[GlobalVmExtensionPolicyInstanceSelector()];

declare 'GlobalVmExtensionPolicyLabelSelector',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyLabelSelector'];

coerce 'GlobalVmExtensionPolicyLabelSelector',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyLabelSelector'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyLabelSelector',
    as ArrayRef[GlobalVmExtensionPolicyLabelSelector()];

coerce 'RepeatedGlobalVmExtensionPolicyLabelSelector',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyLabelSelector'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyLabelSelector',
    as HashRef[GlobalVmExtensionPolicyLabelSelector()];

declare 'InclusionLabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyLabelSelector::InclusionLabelsEntry'];

coerce 'InclusionLabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyLabelSelector::InclusionLabelsEntry'->new($_) };

declare 'RepeatedInclusionLabelsEntry',
    as ArrayRef[InclusionLabelsEntry()];

coerce 'RepeatedInclusionLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyLabelSelector::InclusionLabelsEntry'->new($_) } @$_ ] };

declare 'MapStringInclusionLabelsEntry',
    as HashRef[InclusionLabelsEntry()];

declare 'GlobalVmExtensionPolicyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyList'];

coerce 'GlobalVmExtensionPolicyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyList'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyList',
    as ArrayRef[GlobalVmExtensionPolicyList()];

coerce 'RepeatedGlobalVmExtensionPolicyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyList'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyList',
    as HashRef[GlobalVmExtensionPolicyList()];

declare 'GlobalVmExtensionPolicyRolloutOperation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperation'];

coerce 'GlobalVmExtensionPolicyRolloutOperation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperation'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyRolloutOperation',
    as ArrayRef[GlobalVmExtensionPolicyRolloutOperation()];

coerce 'RepeatedGlobalVmExtensionPolicyRolloutOperation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperation'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyRolloutOperation',
    as HashRef[GlobalVmExtensionPolicyRolloutOperation()];

declare 'GlobalVmExtensionPolicyRolloutOperationRolloutInput',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutInput'];

coerce 'GlobalVmExtensionPolicyRolloutOperationRolloutInput',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutInput'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutInput',
    as ArrayRef[GlobalVmExtensionPolicyRolloutOperationRolloutInput()];

coerce 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutInput',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutInput'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyRolloutOperationRolloutInput',
    as HashRef[GlobalVmExtensionPolicyRolloutOperationRolloutInput()];

declare 'PredefinedRolloutPlan',
    as (Int | Str);

declare 'GlobalVmExtensionPolicyRolloutOperationRolloutStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatus'];

coerce 'GlobalVmExtensionPolicyRolloutOperationRolloutStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatus'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutStatus',
    as ArrayRef[GlobalVmExtensionPolicyRolloutOperationRolloutStatus()];

coerce 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatus'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyRolloutOperationRolloutStatus',
    as HashRef[GlobalVmExtensionPolicyRolloutOperationRolloutStatus()];

declare 'GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata'];

coerce 'GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata',
    as ArrayRef[GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata()];

coerce 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata',
    as HashRef[GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata()];

declare 'State',
    as (Int | Str);

declare 'LocationRolloutStatusEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata::LocationRolloutStatusEntry'];

coerce 'LocationRolloutStatusEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata::LocationRolloutStatusEntry'->new($_) };

declare 'RepeatedLocationRolloutStatusEntry',
    as ArrayRef[LocationRolloutStatusEntry()];

coerce 'RepeatedLocationRolloutStatusEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadata::LocationRolloutStatusEntry'->new($_) } @$_ ] };

declare 'MapStringLocationRolloutStatusEntry',
    as HashRef[LocationRolloutStatusEntry()];

declare 'GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus'];

coerce 'GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus'->new($_) };

declare 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus',
    as ArrayRef[GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus()];

coerce 'RepeatedGlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus'->new($_) } @$_ ] };

declare 'MapStringGlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus',
    as HashRef[GlobalVmExtensionPolicyRolloutOperationRolloutStatusRolloutMetadataLocationRolloutStatus()];

declare 'State',
    as (Int | Str);

declare 'GroupMaintenanceInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GroupMaintenanceInfo'];

coerce 'GroupMaintenanceInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GroupMaintenanceInfo'->new($_) };

declare 'RepeatedGroupMaintenanceInfo',
    as ArrayRef[GroupMaintenanceInfo()];

coerce 'RepeatedGroupMaintenanceInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GroupMaintenanceInfo'->new($_) } @$_ ] };

declare 'MapStringGroupMaintenanceInfo',
    as HashRef[GroupMaintenanceInfo()];

declare 'SchedulingType',
    as (Int | Str);

declare 'GuestAttributes',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GuestAttributes'];

coerce 'GuestAttributes',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GuestAttributes'->new($_) };

declare 'RepeatedGuestAttributes',
    as ArrayRef[GuestAttributes()];

coerce 'RepeatedGuestAttributes',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GuestAttributes'->new($_) } @$_ ] };

declare 'MapStringGuestAttributes',
    as HashRef[GuestAttributes()];

declare 'GuestAttributesEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GuestAttributesEntry'];

coerce 'GuestAttributesEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GuestAttributesEntry'->new($_) };

declare 'RepeatedGuestAttributesEntry',
    as ArrayRef[GuestAttributesEntry()];

coerce 'RepeatedGuestAttributesEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GuestAttributesEntry'->new($_) } @$_ ] };

declare 'MapStringGuestAttributesEntry',
    as HashRef[GuestAttributesEntry()];

declare 'GuestAttributesValue',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GuestAttributesValue'];

coerce 'GuestAttributesValue',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GuestAttributesValue'->new($_) };

declare 'RepeatedGuestAttributesValue',
    as ArrayRef[GuestAttributesValue()];

coerce 'RepeatedGuestAttributesValue',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GuestAttributesValue'->new($_) } @$_ ] };

declare 'MapStringGuestAttributesValue',
    as HashRef[GuestAttributesValue()];

declare 'GuestOsFeature',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::GuestOsFeature'];

coerce 'GuestOsFeature',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::GuestOsFeature'->new($_) };

declare 'RepeatedGuestOsFeature',
    as ArrayRef[GuestOsFeature()];

coerce 'RepeatedGuestOsFeature',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::GuestOsFeature'->new($_) } @$_ ] };

declare 'MapStringGuestOsFeature',
    as HashRef[GuestOsFeature()];

declare 'Type',
    as (Int | Str);

declare 'HTTP2HealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HTTP2HealthCheck'];

coerce 'HTTP2HealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HTTP2HealthCheck'->new($_) };

declare 'RepeatedHTTP2HealthCheck',
    as ArrayRef[HTTP2HealthCheck()];

coerce 'RepeatedHTTP2HealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HTTP2HealthCheck'->new($_) } @$_ ] };

declare 'MapStringHTTP2HealthCheck',
    as HashRef[HTTP2HealthCheck()];

declare 'PortSpecification',
    as (Int | Str);

declare 'ProxyHeader',
    as (Int | Str);

declare 'HTTPHealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HTTPHealthCheck'];

coerce 'HTTPHealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HTTPHealthCheck'->new($_) };

declare 'RepeatedHTTPHealthCheck',
    as ArrayRef[HTTPHealthCheck()];

coerce 'RepeatedHTTPHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HTTPHealthCheck'->new($_) } @$_ ] };

declare 'MapStringHTTPHealthCheck',
    as HashRef[HTTPHealthCheck()];

declare 'PortSpecification',
    as (Int | Str);

declare 'ProxyHeader',
    as (Int | Str);

declare 'HTTPSHealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HTTPSHealthCheck'];

coerce 'HTTPSHealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HTTPSHealthCheck'->new($_) };

declare 'RepeatedHTTPSHealthCheck',
    as ArrayRef[HTTPSHealthCheck()];

coerce 'RepeatedHTTPSHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HTTPSHealthCheck'->new($_) } @$_ ] };

declare 'MapStringHTTPSHealthCheck',
    as HashRef[HTTPSHealthCheck()];

declare 'PortSpecification',
    as (Int | Str);

declare 'ProxyHeader',
    as (Int | Str);

declare 'HealthAggregationPoliciesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthAggregationPoliciesScopedList'];

coerce 'HealthAggregationPoliciesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPoliciesScopedList'->new($_) };

declare 'RepeatedHealthAggregationPoliciesScopedList',
    as ArrayRef[HealthAggregationPoliciesScopedList()];

coerce 'RepeatedHealthAggregationPoliciesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPoliciesScopedList'->new($_) } @$_ ] };

declare 'MapStringHealthAggregationPoliciesScopedList',
    as HashRef[HealthAggregationPoliciesScopedList()];

declare 'HealthAggregationPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthAggregationPolicy'];

coerce 'HealthAggregationPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicy'->new($_) };

declare 'RepeatedHealthAggregationPolicy',
    as ArrayRef[HealthAggregationPolicy()];

coerce 'RepeatedHealthAggregationPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicy'->new($_) } @$_ ] };

declare 'MapStringHealthAggregationPolicy',
    as HashRef[HealthAggregationPolicy()];

declare 'PolicyType',
    as (Int | Str);

declare 'HealthAggregationPolicyAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyAggregatedList'];

coerce 'HealthAggregationPolicyAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyAggregatedList'->new($_) };

declare 'RepeatedHealthAggregationPolicyAggregatedList',
    as ArrayRef[HealthAggregationPolicyAggregatedList()];

coerce 'RepeatedHealthAggregationPolicyAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyAggregatedList'->new($_) } @$_ ] };

declare 'MapStringHealthAggregationPolicyAggregatedList',
    as HashRef[HealthAggregationPolicyAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'HealthAggregationPolicyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyList'];

coerce 'HealthAggregationPolicyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyList'->new($_) };

declare 'RepeatedHealthAggregationPolicyList',
    as ArrayRef[HealthAggregationPolicyList()];

coerce 'RepeatedHealthAggregationPolicyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthAggregationPolicyList'->new($_) } @$_ ] };

declare 'MapStringHealthAggregationPolicyList',
    as HashRef[HealthAggregationPolicyList()];

declare 'HealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheck'];

coerce 'HealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheck'->new($_) };

declare 'RepeatedHealthCheck',
    as ArrayRef[HealthCheck()];

coerce 'RepeatedHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheck'->new($_) } @$_ ] };

declare 'MapStringHealthCheck',
    as HashRef[HealthCheck()];

declare 'Type',
    as (Int | Str);

declare 'HealthCheckList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckList'];

coerce 'HealthCheckList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckList'->new($_) };

declare 'RepeatedHealthCheckList',
    as ArrayRef[HealthCheckList()];

coerce 'RepeatedHealthCheckList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckList'->new($_) } @$_ ] };

declare 'MapStringHealthCheckList',
    as HashRef[HealthCheckList()];

declare 'HealthCheckLogConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckLogConfig'];

coerce 'HealthCheckLogConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckLogConfig'->new($_) };

declare 'RepeatedHealthCheckLogConfig',
    as ArrayRef[HealthCheckLogConfig()];

coerce 'RepeatedHealthCheckLogConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckLogConfig'->new($_) } @$_ ] };

declare 'MapStringHealthCheckLogConfig',
    as HashRef[HealthCheckLogConfig()];

declare 'HealthCheckReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckReference'];

coerce 'HealthCheckReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckReference'->new($_) };

declare 'RepeatedHealthCheckReference',
    as ArrayRef[HealthCheckReference()];

coerce 'RepeatedHealthCheckReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckReference'->new($_) } @$_ ] };

declare 'MapStringHealthCheckReference',
    as HashRef[HealthCheckReference()];

declare 'HealthCheckService',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckService'];

coerce 'HealthCheckService',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckService'->new($_) };

declare 'RepeatedHealthCheckService',
    as ArrayRef[HealthCheckService()];

coerce 'RepeatedHealthCheckService',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckService'->new($_) } @$_ ] };

declare 'MapStringHealthCheckService',
    as HashRef[HealthCheckService()];

declare 'HealthStatusAggregationPolicy',
    as (Int | Str);

declare 'HealthCheckServiceAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckServiceAggregatedList'];

coerce 'HealthCheckServiceAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckServiceAggregatedList'->new($_) };

declare 'RepeatedHealthCheckServiceAggregatedList',
    as ArrayRef[HealthCheckServiceAggregatedList()];

coerce 'RepeatedHealthCheckServiceAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckServiceAggregatedList'->new($_) } @$_ ] };

declare 'MapStringHealthCheckServiceAggregatedList',
    as HashRef[HealthCheckServiceAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckServiceAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckServiceAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckServiceAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'HealthCheckServiceReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckServiceReference'];

coerce 'HealthCheckServiceReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckServiceReference'->new($_) };

declare 'RepeatedHealthCheckServiceReference',
    as ArrayRef[HealthCheckServiceReference()];

coerce 'RepeatedHealthCheckServiceReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckServiceReference'->new($_) } @$_ ] };

declare 'MapStringHealthCheckServiceReference',
    as HashRef[HealthCheckServiceReference()];

declare 'HealthCheckServicesList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckServicesList'];

coerce 'HealthCheckServicesList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckServicesList'->new($_) };

declare 'RepeatedHealthCheckServicesList',
    as ArrayRef[HealthCheckServicesList()];

coerce 'RepeatedHealthCheckServicesList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckServicesList'->new($_) } @$_ ] };

declare 'MapStringHealthCheckServicesList',
    as HashRef[HealthCheckServicesList()];

declare 'HealthCheckServicesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthCheckServicesScopedList'];

coerce 'HealthCheckServicesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthCheckServicesScopedList'->new($_) };

declare 'RepeatedHealthCheckServicesScopedList',
    as ArrayRef[HealthCheckServicesScopedList()];

coerce 'RepeatedHealthCheckServicesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthCheckServicesScopedList'->new($_) } @$_ ] };

declare 'MapStringHealthCheckServicesScopedList',
    as HashRef[HealthCheckServicesScopedList()];

declare 'HealthChecksAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthChecksAggregatedList'];

coerce 'HealthChecksAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthChecksAggregatedList'->new($_) };

declare 'RepeatedHealthChecksAggregatedList',
    as ArrayRef[HealthChecksAggregatedList()];

coerce 'RepeatedHealthChecksAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthChecksAggregatedList'->new($_) } @$_ ] };

declare 'MapStringHealthChecksAggregatedList',
    as HashRef[HealthChecksAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthChecksAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthChecksAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthChecksAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'HealthChecksScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthChecksScopedList'];

coerce 'HealthChecksScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthChecksScopedList'->new($_) };

declare 'RepeatedHealthChecksScopedList',
    as ArrayRef[HealthChecksScopedList()];

coerce 'RepeatedHealthChecksScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthChecksScopedList'->new($_) } @$_ ] };

declare 'MapStringHealthChecksScopedList',
    as HashRef[HealthChecksScopedList()];

declare 'HealthSource',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSource'];

coerce 'HealthSource',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSource'->new($_) };

declare 'RepeatedHealthSource',
    as ArrayRef[HealthSource()];

coerce 'RepeatedHealthSource',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSource'->new($_) } @$_ ] };

declare 'MapStringHealthSource',
    as HashRef[HealthSource()];

declare 'SourceType',
    as (Int | Str);

declare 'HealthSourceAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSourceAggregatedList'];

coerce 'HealthSourceAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSourceAggregatedList'->new($_) };

declare 'RepeatedHealthSourceAggregatedList',
    as ArrayRef[HealthSourceAggregatedList()];

coerce 'RepeatedHealthSourceAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSourceAggregatedList'->new($_) } @$_ ] };

declare 'MapStringHealthSourceAggregatedList',
    as HashRef[HealthSourceAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSourceAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSourceAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSourceAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'HealthSourceHealth',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSourceHealth'];

coerce 'HealthSourceHealth',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSourceHealth'->new($_) };

declare 'RepeatedHealthSourceHealth',
    as ArrayRef[HealthSourceHealth()];

coerce 'RepeatedHealthSourceHealth',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSourceHealth'->new($_) } @$_ ] };

declare 'MapStringHealthSourceHealth',
    as HashRef[HealthSourceHealth()];

declare 'HealthState',
    as (Int | Str);

declare 'HealthSourceList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSourceList'];

coerce 'HealthSourceList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSourceList'->new($_) };

declare 'RepeatedHealthSourceList',
    as ArrayRef[HealthSourceList()];

coerce 'RepeatedHealthSourceList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSourceList'->new($_) } @$_ ] };

declare 'MapStringHealthSourceList',
    as HashRef[HealthSourceList()];

declare 'HealthSourcesGetHealthResponseSourceInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSourcesGetHealthResponseSourceInfo'];

coerce 'HealthSourcesGetHealthResponseSourceInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSourcesGetHealthResponseSourceInfo'->new($_) };

declare 'RepeatedHealthSourcesGetHealthResponseSourceInfo',
    as ArrayRef[HealthSourcesGetHealthResponseSourceInfo()];

coerce 'RepeatedHealthSourcesGetHealthResponseSourceInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSourcesGetHealthResponseSourceInfo'->new($_) } @$_ ] };

declare 'MapStringHealthSourcesGetHealthResponseSourceInfo',
    as HashRef[HealthSourcesGetHealthResponseSourceInfo()];

declare 'HealthSourcesGetHealthResponseSourceInfoBackendInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSourcesGetHealthResponseSourceInfoBackendInfo'];

coerce 'HealthSourcesGetHealthResponseSourceInfoBackendInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSourcesGetHealthResponseSourceInfoBackendInfo'->new($_) };

declare 'RepeatedHealthSourcesGetHealthResponseSourceInfoBackendInfo',
    as ArrayRef[HealthSourcesGetHealthResponseSourceInfoBackendInfo()];

coerce 'RepeatedHealthSourcesGetHealthResponseSourceInfoBackendInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSourcesGetHealthResponseSourceInfoBackendInfo'->new($_) } @$_ ] };

declare 'MapStringHealthSourcesGetHealthResponseSourceInfoBackendInfo',
    as HashRef[HealthSourcesGetHealthResponseSourceInfoBackendInfo()];

declare 'HealthSourcesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthSourcesScopedList'];

coerce 'HealthSourcesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthSourcesScopedList'->new($_) };

declare 'RepeatedHealthSourcesScopedList',
    as ArrayRef[HealthSourcesScopedList()];

coerce 'RepeatedHealthSourcesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthSourcesScopedList'->new($_) } @$_ ] };

declare 'MapStringHealthSourcesScopedList',
    as HashRef[HealthSourcesScopedList()];

declare 'HealthStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthStatus'];

coerce 'HealthStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthStatus'->new($_) };

declare 'RepeatedHealthStatus',
    as ArrayRef[HealthStatus()];

coerce 'RepeatedHealthStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthStatus'->new($_) } @$_ ] };

declare 'MapStringHealthStatus',
    as HashRef[HealthStatus()];

declare 'HealthState',
    as (Int | Str);

declare 'Ipv6HealthState',
    as (Int | Str);

declare 'WeightError',
    as (Int | Str);

declare 'AnnotationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthStatus::AnnotationsEntry'];

coerce 'AnnotationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthStatus::AnnotationsEntry'->new($_) };

declare 'RepeatedAnnotationsEntry',
    as ArrayRef[AnnotationsEntry()];

coerce 'RepeatedAnnotationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthStatus::AnnotationsEntry'->new($_) } @$_ ] };

declare 'MapStringAnnotationsEntry',
    as HashRef[AnnotationsEntry()];

declare 'HealthStatusForNetworkEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HealthStatusForNetworkEndpoint'];

coerce 'HealthStatusForNetworkEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HealthStatusForNetworkEndpoint'->new($_) };

declare 'RepeatedHealthStatusForNetworkEndpoint',
    as ArrayRef[HealthStatusForNetworkEndpoint()];

coerce 'RepeatedHealthStatusForNetworkEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HealthStatusForNetworkEndpoint'->new($_) } @$_ ] };

declare 'MapStringHealthStatusForNetworkEndpoint',
    as HashRef[HealthStatusForNetworkEndpoint()];

declare 'HealthState',
    as (Int | Str);

declare 'Ipv6HealthState',
    as (Int | Str);

declare 'Help',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Help'];

coerce 'Help',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Help'->new($_) };

declare 'RepeatedHelp',
    as ArrayRef[Help()];

coerce 'RepeatedHelp',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Help'->new($_) } @$_ ] };

declare 'MapStringHelp',
    as HashRef[Help()];

declare 'HelpLink',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HelpLink'];

coerce 'HelpLink',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HelpLink'->new($_) };

declare 'RepeatedHelpLink',
    as ArrayRef[HelpLink()];

coerce 'RepeatedHelpLink',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HelpLink'->new($_) } @$_ ] };

declare 'MapStringHelpLink',
    as HashRef[HelpLink()];

declare 'HostRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HostRule'];

coerce 'HostRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HostRule'->new($_) };

declare 'RepeatedHostRule',
    as ArrayRef[HostRule()];

coerce 'RepeatedHostRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HostRule'->new($_) } @$_ ] };

declare 'MapStringHostRule',
    as HashRef[HostRule()];

declare 'HttpFaultAbort',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpFaultAbort'];

coerce 'HttpFaultAbort',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpFaultAbort'->new($_) };

declare 'RepeatedHttpFaultAbort',
    as ArrayRef[HttpFaultAbort()];

coerce 'RepeatedHttpFaultAbort',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpFaultAbort'->new($_) } @$_ ] };

declare 'MapStringHttpFaultAbort',
    as HashRef[HttpFaultAbort()];

declare 'HttpFaultDelay',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpFaultDelay'];

coerce 'HttpFaultDelay',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpFaultDelay'->new($_) };

declare 'RepeatedHttpFaultDelay',
    as ArrayRef[HttpFaultDelay()];

coerce 'RepeatedHttpFaultDelay',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpFaultDelay'->new($_) } @$_ ] };

declare 'MapStringHttpFaultDelay',
    as HashRef[HttpFaultDelay()];

declare 'HttpFaultInjection',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpFaultInjection'];

coerce 'HttpFaultInjection',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpFaultInjection'->new($_) };

declare 'RepeatedHttpFaultInjection',
    as ArrayRef[HttpFaultInjection()];

coerce 'RepeatedHttpFaultInjection',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpFaultInjection'->new($_) } @$_ ] };

declare 'MapStringHttpFaultInjection',
    as HashRef[HttpFaultInjection()];

declare 'HttpHeaderAction',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpHeaderAction'];

coerce 'HttpHeaderAction',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpHeaderAction'->new($_) };

declare 'RepeatedHttpHeaderAction',
    as ArrayRef[HttpHeaderAction()];

coerce 'RepeatedHttpHeaderAction',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpHeaderAction'->new($_) } @$_ ] };

declare 'MapStringHttpHeaderAction',
    as HashRef[HttpHeaderAction()];

declare 'HttpHeaderMatch',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpHeaderMatch'];

coerce 'HttpHeaderMatch',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpHeaderMatch'->new($_) };

declare 'RepeatedHttpHeaderMatch',
    as ArrayRef[HttpHeaderMatch()];

coerce 'RepeatedHttpHeaderMatch',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpHeaderMatch'->new($_) } @$_ ] };

declare 'MapStringHttpHeaderMatch',
    as HashRef[HttpHeaderMatch()];

declare 'HttpHeaderOption',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpHeaderOption'];

coerce 'HttpHeaderOption',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpHeaderOption'->new($_) };

declare 'RepeatedHttpHeaderOption',
    as ArrayRef[HttpHeaderOption()];

coerce 'RepeatedHttpHeaderOption',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpHeaderOption'->new($_) } @$_ ] };

declare 'MapStringHttpHeaderOption',
    as HashRef[HttpHeaderOption()];

declare 'HttpQueryParameterMatch',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpQueryParameterMatch'];

coerce 'HttpQueryParameterMatch',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpQueryParameterMatch'->new($_) };

declare 'RepeatedHttpQueryParameterMatch',
    as ArrayRef[HttpQueryParameterMatch()];

coerce 'RepeatedHttpQueryParameterMatch',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpQueryParameterMatch'->new($_) } @$_ ] };

declare 'MapStringHttpQueryParameterMatch',
    as HashRef[HttpQueryParameterMatch()];

declare 'HttpRedirectAction',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpRedirectAction'];

coerce 'HttpRedirectAction',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpRedirectAction'->new($_) };

declare 'RepeatedHttpRedirectAction',
    as ArrayRef[HttpRedirectAction()];

coerce 'RepeatedHttpRedirectAction',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpRedirectAction'->new($_) } @$_ ] };

declare 'MapStringHttpRedirectAction',
    as HashRef[HttpRedirectAction()];

declare 'RedirectResponseCode',
    as (Int | Str);

declare 'HttpRetryPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpRetryPolicy'];

coerce 'HttpRetryPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpRetryPolicy'->new($_) };

declare 'RepeatedHttpRetryPolicy',
    as ArrayRef[HttpRetryPolicy()];

coerce 'RepeatedHttpRetryPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpRetryPolicy'->new($_) } @$_ ] };

declare 'MapStringHttpRetryPolicy',
    as HashRef[HttpRetryPolicy()];

declare 'HttpRouteAction',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpRouteAction'];

coerce 'HttpRouteAction',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpRouteAction'->new($_) };

declare 'RepeatedHttpRouteAction',
    as ArrayRef[HttpRouteAction()];

coerce 'RepeatedHttpRouteAction',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpRouteAction'->new($_) } @$_ ] };

declare 'MapStringHttpRouteAction',
    as HashRef[HttpRouteAction()];

declare 'HttpRouteRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpRouteRule'];

coerce 'HttpRouteRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpRouteRule'->new($_) };

declare 'RepeatedHttpRouteRule',
    as ArrayRef[HttpRouteRule()];

coerce 'RepeatedHttpRouteRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpRouteRule'->new($_) } @$_ ] };

declare 'MapStringHttpRouteRule',
    as HashRef[HttpRouteRule()];

declare 'HttpRouteRuleMatch',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::HttpRouteRuleMatch'];

coerce 'HttpRouteRuleMatch',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::HttpRouteRuleMatch'->new($_) };

declare 'RepeatedHttpRouteRuleMatch',
    as ArrayRef[HttpRouteRuleMatch()];

coerce 'RepeatedHttpRouteRuleMatch',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::HttpRouteRuleMatch'->new($_) } @$_ ] };

declare 'MapStringHttpRouteRuleMatch',
    as HashRef[HttpRouteRuleMatch()];

declare 'Image',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Image'];

coerce 'Image',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Image'->new($_) };

declare 'RepeatedImage',
    as ArrayRef[Image()];

coerce 'RepeatedImage',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Image'->new($_) } @$_ ] };

declare 'MapStringImage',
    as HashRef[Image()];

declare 'Architecture',
    as (Int | Str);

declare 'SourceType',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Image::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Image::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Image::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'ImageFamilyView',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ImageFamilyView'];

coerce 'ImageFamilyView',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ImageFamilyView'->new($_) };

declare 'RepeatedImageFamilyView',
    as ArrayRef[ImageFamilyView()];

coerce 'RepeatedImageFamilyView',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ImageFamilyView'->new($_) } @$_ ] };

declare 'MapStringImageFamilyView',
    as HashRef[ImageFamilyView()];

declare 'ImageList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ImageList'];

coerce 'ImageList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ImageList'->new($_) };

declare 'RepeatedImageList',
    as ArrayRef[ImageList()];

coerce 'RepeatedImageList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ImageList'->new($_) } @$_ ] };

declare 'MapStringImageList',
    as HashRef[ImageList()];

declare 'ImageParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ImageParams'];

coerce 'ImageParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ImageParams'->new($_) };

declare 'RepeatedImageParams',
    as ArrayRef[ImageParams()];

coerce 'RepeatedImageParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ImageParams'->new($_) } @$_ ] };

declare 'MapStringImageParams',
    as HashRef[ImageParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ImageParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ImageParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ImageParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'InitialStateConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InitialStateConfig'];

coerce 'InitialStateConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InitialStateConfig'->new($_) };

declare 'RepeatedInitialStateConfig',
    as ArrayRef[InitialStateConfig()];

coerce 'RepeatedInitialStateConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InitialStateConfig'->new($_) } @$_ ] };

declare 'MapStringInitialStateConfig',
    as HashRef[InitialStateConfig()];

declare 'InsertAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertAddressRequest'];

coerce 'InsertAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertAddressRequest'->new($_) };

declare 'RepeatedInsertAddressRequest',
    as ArrayRef[InsertAddressRequest()];

coerce 'RepeatedInsertAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertAddressRequest'->new($_) } @$_ ] };

declare 'MapStringInsertAddressRequest',
    as HashRef[InsertAddressRequest()];

declare 'InsertAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertAutoscalerRequest'];

coerce 'InsertAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertAutoscalerRequest'->new($_) };

declare 'RepeatedInsertAutoscalerRequest',
    as ArrayRef[InsertAutoscalerRequest()];

coerce 'RepeatedInsertAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringInsertAutoscalerRequest',
    as HashRef[InsertAutoscalerRequest()];

declare 'InsertBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertBackendBucketRequest'];

coerce 'InsertBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertBackendBucketRequest'->new($_) };

declare 'RepeatedInsertBackendBucketRequest',
    as ArrayRef[InsertBackendBucketRequest()];

coerce 'RepeatedInsertBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringInsertBackendBucketRequest',
    as HashRef[InsertBackendBucketRequest()];

declare 'InsertBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertBackendServiceRequest'];

coerce 'InsertBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertBackendServiceRequest'->new($_) };

declare 'RepeatedInsertBackendServiceRequest',
    as ArrayRef[InsertBackendServiceRequest()];

coerce 'RepeatedInsertBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringInsertBackendServiceRequest',
    as HashRef[InsertBackendServiceRequest()];

declare 'InsertCrossSiteNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertCrossSiteNetworkRequest'];

coerce 'InsertCrossSiteNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertCrossSiteNetworkRequest'->new($_) };

declare 'RepeatedInsertCrossSiteNetworkRequest',
    as ArrayRef[InsertCrossSiteNetworkRequest()];

coerce 'RepeatedInsertCrossSiteNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertCrossSiteNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringInsertCrossSiteNetworkRequest',
    as HashRef[InsertCrossSiteNetworkRequest()];

declare 'InsertDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertDiskRequest'];

coerce 'InsertDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertDiskRequest'->new($_) };

declare 'RepeatedInsertDiskRequest',
    as ArrayRef[InsertDiskRequest()];

coerce 'RepeatedInsertDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertDiskRequest'->new($_) } @$_ ] };

declare 'MapStringInsertDiskRequest',
    as HashRef[InsertDiskRequest()];

declare 'InsertExternalVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertExternalVpnGatewayRequest'];

coerce 'InsertExternalVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertExternalVpnGatewayRequest'->new($_) };

declare 'RepeatedInsertExternalVpnGatewayRequest',
    as ArrayRef[InsertExternalVpnGatewayRequest()];

coerce 'RepeatedInsertExternalVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertExternalVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringInsertExternalVpnGatewayRequest',
    as HashRef[InsertExternalVpnGatewayRequest()];

declare 'InsertFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertFirewallPolicyRequest'];

coerce 'InsertFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertFirewallPolicyRequest'->new($_) };

declare 'RepeatedInsertFirewallPolicyRequest',
    as ArrayRef[InsertFirewallPolicyRequest()];

coerce 'RepeatedInsertFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertFirewallPolicyRequest',
    as HashRef[InsertFirewallPolicyRequest()];

declare 'InsertFirewallRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertFirewallRequest'];

coerce 'InsertFirewallRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertFirewallRequest'->new($_) };

declare 'RepeatedInsertFirewallRequest',
    as ArrayRef[InsertFirewallRequest()];

coerce 'RepeatedInsertFirewallRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertFirewallRequest'->new($_) } @$_ ] };

declare 'MapStringInsertFirewallRequest',
    as HashRef[InsertFirewallRequest()];

declare 'InsertForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertForwardingRuleRequest'];

coerce 'InsertForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertForwardingRuleRequest'->new($_) };

declare 'RepeatedInsertForwardingRuleRequest',
    as ArrayRef[InsertForwardingRuleRequest()];

coerce 'RepeatedInsertForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringInsertForwardingRuleRequest',
    as HashRef[InsertForwardingRuleRequest()];

declare 'InsertFutureReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertFutureReservationRequest'];

coerce 'InsertFutureReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertFutureReservationRequest'->new($_) };

declare 'RepeatedInsertFutureReservationRequest',
    as ArrayRef[InsertFutureReservationRequest()];

coerce 'RepeatedInsertFutureReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertFutureReservationRequest'->new($_) } @$_ ] };

declare 'MapStringInsertFutureReservationRequest',
    as HashRef[InsertFutureReservationRequest()];

declare 'InsertGlobalAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertGlobalAddressRequest'];

coerce 'InsertGlobalAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertGlobalAddressRequest'->new($_) };

declare 'RepeatedInsertGlobalAddressRequest',
    as ArrayRef[InsertGlobalAddressRequest()];

coerce 'RepeatedInsertGlobalAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertGlobalAddressRequest'->new($_) } @$_ ] };

declare 'MapStringInsertGlobalAddressRequest',
    as HashRef[InsertGlobalAddressRequest()];

declare 'InsertGlobalForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertGlobalForwardingRuleRequest'];

coerce 'InsertGlobalForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertGlobalForwardingRuleRequest'->new($_) };

declare 'RepeatedInsertGlobalForwardingRuleRequest',
    as ArrayRef[InsertGlobalForwardingRuleRequest()];

coerce 'RepeatedInsertGlobalForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertGlobalForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringInsertGlobalForwardingRuleRequest',
    as HashRef[InsertGlobalForwardingRuleRequest()];

declare 'InsertGlobalNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertGlobalNetworkEndpointGroupRequest'];

coerce 'InsertGlobalNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertGlobalNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedInsertGlobalNetworkEndpointGroupRequest',
    as ArrayRef[InsertGlobalNetworkEndpointGroupRequest()];

coerce 'RepeatedInsertGlobalNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertGlobalNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertGlobalNetworkEndpointGroupRequest',
    as HashRef[InsertGlobalNetworkEndpointGroupRequest()];

declare 'InsertGlobalPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertGlobalPublicDelegatedPrefixeRequest'];

coerce 'InsertGlobalPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertGlobalPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedInsertGlobalPublicDelegatedPrefixeRequest',
    as ArrayRef[InsertGlobalPublicDelegatedPrefixeRequest()];

coerce 'RepeatedInsertGlobalPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertGlobalPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringInsertGlobalPublicDelegatedPrefixeRequest',
    as HashRef[InsertGlobalPublicDelegatedPrefixeRequest()];

declare 'InsertGlobalVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertGlobalVmExtensionPolicyRequest'];

coerce 'InsertGlobalVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertGlobalVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedInsertGlobalVmExtensionPolicyRequest',
    as ArrayRef[InsertGlobalVmExtensionPolicyRequest()];

coerce 'RepeatedInsertGlobalVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertGlobalVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertGlobalVmExtensionPolicyRequest',
    as HashRef[InsertGlobalVmExtensionPolicyRequest()];

declare 'InsertHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertHealthCheckRequest'];

coerce 'InsertHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertHealthCheckRequest'->new($_) };

declare 'RepeatedInsertHealthCheckRequest',
    as ArrayRef[InsertHealthCheckRequest()];

coerce 'RepeatedInsertHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringInsertHealthCheckRequest',
    as HashRef[InsertHealthCheckRequest()];

declare 'InsertImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertImageRequest'];

coerce 'InsertImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertImageRequest'->new($_) };

declare 'RepeatedInsertImageRequest',
    as ArrayRef[InsertImageRequest()];

coerce 'RepeatedInsertImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertImageRequest'->new($_) } @$_ ] };

declare 'MapStringInsertImageRequest',
    as HashRef[InsertImageRequest()];

declare 'InsertInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInstanceGroupManagerRequest'];

coerce 'InsertInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedInsertInstanceGroupManagerRequest',
    as ArrayRef[InsertInstanceGroupManagerRequest()];

coerce 'RepeatedInsertInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInstanceGroupManagerRequest',
    as HashRef[InsertInstanceGroupManagerRequest()];

declare 'InsertInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInstanceGroupManagerResizeRequestRequest'];

coerce 'InsertInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedInsertInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[InsertInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedInsertInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInstanceGroupManagerResizeRequestRequest',
    as HashRef[InsertInstanceGroupManagerResizeRequestRequest()];

declare 'InsertInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInstanceGroupRequest'];

coerce 'InsertInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInstanceGroupRequest'->new($_) };

declare 'RepeatedInsertInstanceGroupRequest',
    as ArrayRef[InsertInstanceGroupRequest()];

coerce 'RepeatedInsertInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInstanceGroupRequest',
    as HashRef[InsertInstanceGroupRequest()];

declare 'InsertInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInstanceRequest'];

coerce 'InsertInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInstanceRequest'->new($_) };

declare 'RepeatedInsertInstanceRequest',
    as ArrayRef[InsertInstanceRequest()];

coerce 'RepeatedInsertInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInstanceRequest',
    as HashRef[InsertInstanceRequest()];

declare 'InsertInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInstanceTemplateRequest'];

coerce 'InsertInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInstanceTemplateRequest'->new($_) };

declare 'RepeatedInsertInstanceTemplateRequest',
    as ArrayRef[InsertInstanceTemplateRequest()];

coerce 'RepeatedInsertInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInstanceTemplateRequest',
    as HashRef[InsertInstanceTemplateRequest()];

declare 'InsertInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInstantSnapshotGroupRequest'];

coerce 'InsertInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedInsertInstantSnapshotGroupRequest',
    as ArrayRef[InsertInstantSnapshotGroupRequest()];

coerce 'RepeatedInsertInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInstantSnapshotGroupRequest',
    as HashRef[InsertInstantSnapshotGroupRequest()];

declare 'InsertInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInstantSnapshotRequest'];

coerce 'InsertInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInstantSnapshotRequest'->new($_) };

declare 'RepeatedInsertInstantSnapshotRequest',
    as ArrayRef[InsertInstantSnapshotRequest()];

coerce 'RepeatedInsertInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInstantSnapshotRequest',
    as HashRef[InsertInstantSnapshotRequest()];

declare 'InsertInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInterconnectAttachmentGroupRequest'];

coerce 'InsertInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedInsertInterconnectAttachmentGroupRequest',
    as ArrayRef[InsertInterconnectAttachmentGroupRequest()];

coerce 'RepeatedInsertInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInterconnectAttachmentGroupRequest',
    as HashRef[InsertInterconnectAttachmentGroupRequest()];

declare 'InsertInterconnectAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInterconnectAttachmentRequest'];

coerce 'InsertInterconnectAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectAttachmentRequest'->new($_) };

declare 'RepeatedInsertInterconnectAttachmentRequest',
    as ArrayRef[InsertInterconnectAttachmentRequest()];

coerce 'RepeatedInsertInterconnectAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInterconnectAttachmentRequest',
    as HashRef[InsertInterconnectAttachmentRequest()];

declare 'InsertInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInterconnectGroupRequest'];

coerce 'InsertInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectGroupRequest'->new($_) };

declare 'RepeatedInsertInterconnectGroupRequest',
    as ArrayRef[InsertInterconnectGroupRequest()];

coerce 'RepeatedInsertInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInterconnectGroupRequest',
    as HashRef[InsertInterconnectGroupRequest()];

declare 'InsertInterconnectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertInterconnectRequest'];

coerce 'InsertInterconnectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectRequest'->new($_) };

declare 'RepeatedInsertInterconnectRequest',
    as ArrayRef[InsertInterconnectRequest()];

coerce 'RepeatedInsertInterconnectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertInterconnectRequest'->new($_) } @$_ ] };

declare 'MapStringInsertInterconnectRequest',
    as HashRef[InsertInterconnectRequest()];

declare 'InsertLicenseRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertLicenseRequest'];

coerce 'InsertLicenseRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertLicenseRequest'->new($_) };

declare 'RepeatedInsertLicenseRequest',
    as ArrayRef[InsertLicenseRequest()];

coerce 'RepeatedInsertLicenseRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertLicenseRequest'->new($_) } @$_ ] };

declare 'MapStringInsertLicenseRequest',
    as HashRef[InsertLicenseRequest()];

declare 'InsertMachineImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertMachineImageRequest'];

coerce 'InsertMachineImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertMachineImageRequest'->new($_) };

declare 'RepeatedInsertMachineImageRequest',
    as ArrayRef[InsertMachineImageRequest()];

coerce 'RepeatedInsertMachineImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertMachineImageRequest'->new($_) } @$_ ] };

declare 'MapStringInsertMachineImageRequest',
    as HashRef[InsertMachineImageRequest()];

declare 'InsertNetworkAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertNetworkAttachmentRequest'];

coerce 'InsertNetworkAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertNetworkAttachmentRequest'->new($_) };

declare 'RepeatedInsertNetworkAttachmentRequest',
    as ArrayRef[InsertNetworkAttachmentRequest()];

coerce 'RepeatedInsertNetworkAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertNetworkAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringInsertNetworkAttachmentRequest',
    as HashRef[InsertNetworkAttachmentRequest()];

declare 'InsertNetworkEdgeSecurityServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertNetworkEdgeSecurityServiceRequest'];

coerce 'InsertNetworkEdgeSecurityServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertNetworkEdgeSecurityServiceRequest'->new($_) };

declare 'RepeatedInsertNetworkEdgeSecurityServiceRequest',
    as ArrayRef[InsertNetworkEdgeSecurityServiceRequest()];

coerce 'RepeatedInsertNetworkEdgeSecurityServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertNetworkEdgeSecurityServiceRequest'->new($_) } @$_ ] };

declare 'MapStringInsertNetworkEdgeSecurityServiceRequest',
    as HashRef[InsertNetworkEdgeSecurityServiceRequest()];

declare 'InsertNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertNetworkEndpointGroupRequest'];

coerce 'InsertNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedInsertNetworkEndpointGroupRequest',
    as ArrayRef[InsertNetworkEndpointGroupRequest()];

coerce 'RepeatedInsertNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertNetworkEndpointGroupRequest',
    as HashRef[InsertNetworkEndpointGroupRequest()];

declare 'InsertNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertNetworkFirewallPolicyRequest'];

coerce 'InsertNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedInsertNetworkFirewallPolicyRequest',
    as ArrayRef[InsertNetworkFirewallPolicyRequest()];

coerce 'RepeatedInsertNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertNetworkFirewallPolicyRequest',
    as HashRef[InsertNetworkFirewallPolicyRequest()];

declare 'InsertNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertNetworkRequest'];

coerce 'InsertNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertNetworkRequest'->new($_) };

declare 'RepeatedInsertNetworkRequest',
    as ArrayRef[InsertNetworkRequest()];

coerce 'RepeatedInsertNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringInsertNetworkRequest',
    as HashRef[InsertNetworkRequest()];

declare 'InsertNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertNodeGroupRequest'];

coerce 'InsertNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertNodeGroupRequest'->new($_) };

declare 'RepeatedInsertNodeGroupRequest',
    as ArrayRef[InsertNodeGroupRequest()];

coerce 'RepeatedInsertNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertNodeGroupRequest',
    as HashRef[InsertNodeGroupRequest()];

declare 'InsertNodeTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertNodeTemplateRequest'];

coerce 'InsertNodeTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertNodeTemplateRequest'->new($_) };

declare 'RepeatedInsertNodeTemplateRequest',
    as ArrayRef[InsertNodeTemplateRequest()];

coerce 'RepeatedInsertNodeTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertNodeTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringInsertNodeTemplateRequest',
    as HashRef[InsertNodeTemplateRequest()];

declare 'InsertOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertOrganizationSecurityPolicyRequest'];

coerce 'InsertOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedInsertOrganizationSecurityPolicyRequest',
    as ArrayRef[InsertOrganizationSecurityPolicyRequest()];

coerce 'RepeatedInsertOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertOrganizationSecurityPolicyRequest',
    as HashRef[InsertOrganizationSecurityPolicyRequest()];

declare 'InsertPacketMirroringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertPacketMirroringRequest'];

coerce 'InsertPacketMirroringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertPacketMirroringRequest'->new($_) };

declare 'RepeatedInsertPacketMirroringRequest',
    as ArrayRef[InsertPacketMirroringRequest()];

coerce 'RepeatedInsertPacketMirroringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertPacketMirroringRequest'->new($_) } @$_ ] };

declare 'MapStringInsertPacketMirroringRequest',
    as HashRef[InsertPacketMirroringRequest()];

declare 'InsertPublicAdvertisedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertPublicAdvertisedPrefixeRequest'];

coerce 'InsertPublicAdvertisedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertPublicAdvertisedPrefixeRequest'->new($_) };

declare 'RepeatedInsertPublicAdvertisedPrefixeRequest',
    as ArrayRef[InsertPublicAdvertisedPrefixeRequest()];

coerce 'RepeatedInsertPublicAdvertisedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertPublicAdvertisedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringInsertPublicAdvertisedPrefixeRequest',
    as HashRef[InsertPublicAdvertisedPrefixeRequest()];

declare 'InsertPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertPublicDelegatedPrefixeRequest'];

coerce 'InsertPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedInsertPublicDelegatedPrefixeRequest',
    as ArrayRef[InsertPublicDelegatedPrefixeRequest()];

coerce 'RepeatedInsertPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringInsertPublicDelegatedPrefixeRequest',
    as HashRef[InsertPublicDelegatedPrefixeRequest()];

declare 'InsertRegionAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionAutoscalerRequest'];

coerce 'InsertRegionAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionAutoscalerRequest'->new($_) };

declare 'RepeatedInsertRegionAutoscalerRequest',
    as ArrayRef[InsertRegionAutoscalerRequest()];

coerce 'RepeatedInsertRegionAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionAutoscalerRequest',
    as HashRef[InsertRegionAutoscalerRequest()];

declare 'InsertRegionBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionBackendBucketRequest'];

coerce 'InsertRegionBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionBackendBucketRequest'->new($_) };

declare 'RepeatedInsertRegionBackendBucketRequest',
    as ArrayRef[InsertRegionBackendBucketRequest()];

coerce 'RepeatedInsertRegionBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionBackendBucketRequest',
    as HashRef[InsertRegionBackendBucketRequest()];

declare 'InsertRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionBackendServiceRequest'];

coerce 'InsertRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionBackendServiceRequest'->new($_) };

declare 'RepeatedInsertRegionBackendServiceRequest',
    as ArrayRef[InsertRegionBackendServiceRequest()];

coerce 'RepeatedInsertRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionBackendServiceRequest',
    as HashRef[InsertRegionBackendServiceRequest()];

declare 'InsertRegionCommitmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionCommitmentRequest'];

coerce 'InsertRegionCommitmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionCommitmentRequest'->new($_) };

declare 'RepeatedInsertRegionCommitmentRequest',
    as ArrayRef[InsertRegionCommitmentRequest()];

coerce 'RepeatedInsertRegionCommitmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionCommitmentRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionCommitmentRequest',
    as HashRef[InsertRegionCommitmentRequest()];

declare 'InsertRegionCompositeHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionCompositeHealthCheckRequest'];

coerce 'InsertRegionCompositeHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionCompositeHealthCheckRequest'->new($_) };

declare 'RepeatedInsertRegionCompositeHealthCheckRequest',
    as ArrayRef[InsertRegionCompositeHealthCheckRequest()];

coerce 'RepeatedInsertRegionCompositeHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionCompositeHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionCompositeHealthCheckRequest',
    as HashRef[InsertRegionCompositeHealthCheckRequest()];

declare 'InsertRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionDiskRequest'];

coerce 'InsertRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionDiskRequest'->new($_) };

declare 'RepeatedInsertRegionDiskRequest',
    as ArrayRef[InsertRegionDiskRequest()];

coerce 'RepeatedInsertRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionDiskRequest',
    as HashRef[InsertRegionDiskRequest()];

declare 'InsertRegionHealthAggregationPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionHealthAggregationPolicyRequest'];

coerce 'InsertRegionHealthAggregationPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthAggregationPolicyRequest'->new($_) };

declare 'RepeatedInsertRegionHealthAggregationPolicyRequest',
    as ArrayRef[InsertRegionHealthAggregationPolicyRequest()];

coerce 'RepeatedInsertRegionHealthAggregationPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthAggregationPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionHealthAggregationPolicyRequest',
    as HashRef[InsertRegionHealthAggregationPolicyRequest()];

declare 'InsertRegionHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionHealthCheckRequest'];

coerce 'InsertRegionHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthCheckRequest'->new($_) };

declare 'RepeatedInsertRegionHealthCheckRequest',
    as ArrayRef[InsertRegionHealthCheckRequest()];

coerce 'RepeatedInsertRegionHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionHealthCheckRequest',
    as HashRef[InsertRegionHealthCheckRequest()];

declare 'InsertRegionHealthCheckServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionHealthCheckServiceRequest'];

coerce 'InsertRegionHealthCheckServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthCheckServiceRequest'->new($_) };

declare 'RepeatedInsertRegionHealthCheckServiceRequest',
    as ArrayRef[InsertRegionHealthCheckServiceRequest()];

coerce 'RepeatedInsertRegionHealthCheckServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthCheckServiceRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionHealthCheckServiceRequest',
    as HashRef[InsertRegionHealthCheckServiceRequest()];

declare 'InsertRegionHealthSourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionHealthSourceRequest'];

coerce 'InsertRegionHealthSourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthSourceRequest'->new($_) };

declare 'RepeatedInsertRegionHealthSourceRequest',
    as ArrayRef[InsertRegionHealthSourceRequest()];

coerce 'RepeatedInsertRegionHealthSourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionHealthSourceRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionHealthSourceRequest',
    as HashRef[InsertRegionHealthSourceRequest()];

declare 'InsertRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionInstanceGroupManagerRequest'];

coerce 'InsertRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedInsertRegionInstanceGroupManagerRequest',
    as ArrayRef[InsertRegionInstanceGroupManagerRequest()];

coerce 'RepeatedInsertRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionInstanceGroupManagerRequest',
    as HashRef[InsertRegionInstanceGroupManagerRequest()];

declare 'InsertRegionInstanceGroupManagerResizeRequestRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionInstanceGroupManagerResizeRequestRequest'];

coerce 'InsertRegionInstanceGroupManagerResizeRequestRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstanceGroupManagerResizeRequestRequest'->new($_) };

declare 'RepeatedInsertRegionInstanceGroupManagerResizeRequestRequest',
    as ArrayRef[InsertRegionInstanceGroupManagerResizeRequestRequest()];

coerce 'RepeatedInsertRegionInstanceGroupManagerResizeRequestRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstanceGroupManagerResizeRequestRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionInstanceGroupManagerResizeRequestRequest',
    as HashRef[InsertRegionInstanceGroupManagerResizeRequestRequest()];

declare 'InsertRegionInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionInstanceTemplateRequest'];

coerce 'InsertRegionInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstanceTemplateRequest'->new($_) };

declare 'RepeatedInsertRegionInstanceTemplateRequest',
    as ArrayRef[InsertRegionInstanceTemplateRequest()];

coerce 'RepeatedInsertRegionInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionInstanceTemplateRequest',
    as HashRef[InsertRegionInstanceTemplateRequest()];

declare 'InsertRegionInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionInstantSnapshotGroupRequest'];

coerce 'InsertRegionInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedInsertRegionInstantSnapshotGroupRequest',
    as ArrayRef[InsertRegionInstantSnapshotGroupRequest()];

coerce 'RepeatedInsertRegionInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionInstantSnapshotGroupRequest',
    as HashRef[InsertRegionInstantSnapshotGroupRequest()];

declare 'InsertRegionInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionInstantSnapshotRequest'];

coerce 'InsertRegionInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstantSnapshotRequest'->new($_) };

declare 'RepeatedInsertRegionInstantSnapshotRequest',
    as ArrayRef[InsertRegionInstantSnapshotRequest()];

coerce 'RepeatedInsertRegionInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionInstantSnapshotRequest',
    as HashRef[InsertRegionInstantSnapshotRequest()];

declare 'InsertRegionNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionNetworkEndpointGroupRequest'];

coerce 'InsertRegionNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedInsertRegionNetworkEndpointGroupRequest',
    as ArrayRef[InsertRegionNetworkEndpointGroupRequest()];

coerce 'RepeatedInsertRegionNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionNetworkEndpointGroupRequest',
    as HashRef[InsertRegionNetworkEndpointGroupRequest()];

declare 'InsertRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionNetworkFirewallPolicyRequest'];

coerce 'InsertRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedInsertRegionNetworkFirewallPolicyRequest',
    as ArrayRef[InsertRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedInsertRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionNetworkFirewallPolicyRequest',
    as HashRef[InsertRegionNetworkFirewallPolicyRequest()];

declare 'InsertRegionNotificationEndpointRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionNotificationEndpointRequest'];

coerce 'InsertRegionNotificationEndpointRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionNotificationEndpointRequest'->new($_) };

declare 'RepeatedInsertRegionNotificationEndpointRequest',
    as ArrayRef[InsertRegionNotificationEndpointRequest()];

coerce 'RepeatedInsertRegionNotificationEndpointRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionNotificationEndpointRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionNotificationEndpointRequest',
    as HashRef[InsertRegionNotificationEndpointRequest()];

declare 'InsertRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionSecurityPolicyRequest'];

coerce 'InsertRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedInsertRegionSecurityPolicyRequest',
    as ArrayRef[InsertRegionSecurityPolicyRequest()];

coerce 'RepeatedInsertRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionSecurityPolicyRequest',
    as HashRef[InsertRegionSecurityPolicyRequest()];

declare 'InsertRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionSnapshotRequest'];

coerce 'InsertRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionSnapshotRequest'->new($_) };

declare 'RepeatedInsertRegionSnapshotRequest',
    as ArrayRef[InsertRegionSnapshotRequest()];

coerce 'RepeatedInsertRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionSnapshotRequest',
    as HashRef[InsertRegionSnapshotRequest()];

declare 'InsertRegionSslCertificateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionSslCertificateRequest'];

coerce 'InsertRegionSslCertificateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionSslCertificateRequest'->new($_) };

declare 'RepeatedInsertRegionSslCertificateRequest',
    as ArrayRef[InsertRegionSslCertificateRequest()];

coerce 'RepeatedInsertRegionSslCertificateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionSslCertificateRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionSslCertificateRequest',
    as HashRef[InsertRegionSslCertificateRequest()];

declare 'InsertRegionSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionSslPolicyRequest'];

coerce 'InsertRegionSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionSslPolicyRequest'->new($_) };

declare 'RepeatedInsertRegionSslPolicyRequest',
    as ArrayRef[InsertRegionSslPolicyRequest()];

coerce 'RepeatedInsertRegionSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionSslPolicyRequest',
    as HashRef[InsertRegionSslPolicyRequest()];

declare 'InsertRegionTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionTargetHttpProxyRequest'];

coerce 'InsertRegionTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionTargetHttpProxyRequest'->new($_) };

declare 'RepeatedInsertRegionTargetHttpProxyRequest',
    as ArrayRef[InsertRegionTargetHttpProxyRequest()];

coerce 'RepeatedInsertRegionTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionTargetHttpProxyRequest',
    as HashRef[InsertRegionTargetHttpProxyRequest()];

declare 'InsertRegionTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionTargetHttpsProxyRequest'];

coerce 'InsertRegionTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedInsertRegionTargetHttpsProxyRequest',
    as ArrayRef[InsertRegionTargetHttpsProxyRequest()];

coerce 'RepeatedInsertRegionTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionTargetHttpsProxyRequest',
    as HashRef[InsertRegionTargetHttpsProxyRequest()];

declare 'InsertRegionTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionTargetTcpProxyRequest'];

coerce 'InsertRegionTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionTargetTcpProxyRequest'->new($_) };

declare 'RepeatedInsertRegionTargetTcpProxyRequest',
    as ArrayRef[InsertRegionTargetTcpProxyRequest()];

coerce 'RepeatedInsertRegionTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionTargetTcpProxyRequest',
    as HashRef[InsertRegionTargetTcpProxyRequest()];

declare 'InsertRegionUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRegionUrlMapRequest'];

coerce 'InsertRegionUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRegionUrlMapRequest'->new($_) };

declare 'RepeatedInsertRegionUrlMapRequest',
    as ArrayRef[InsertRegionUrlMapRequest()];

coerce 'RepeatedInsertRegionUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRegionUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRegionUrlMapRequest',
    as HashRef[InsertRegionUrlMapRequest()];

declare 'InsertReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertReservationRequest'];

coerce 'InsertReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertReservationRequest'->new($_) };

declare 'RepeatedInsertReservationRequest',
    as ArrayRef[InsertReservationRequest()];

coerce 'RepeatedInsertReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertReservationRequest'->new($_) } @$_ ] };

declare 'MapStringInsertReservationRequest',
    as HashRef[InsertReservationRequest()];

declare 'InsertResourcePolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertResourcePolicyRequest'];

coerce 'InsertResourcePolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertResourcePolicyRequest'->new($_) };

declare 'RepeatedInsertResourcePolicyRequest',
    as ArrayRef[InsertResourcePolicyRequest()];

coerce 'RepeatedInsertResourcePolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertResourcePolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertResourcePolicyRequest',
    as HashRef[InsertResourcePolicyRequest()];

declare 'InsertRolloutPlanRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRolloutPlanRequest'];

coerce 'InsertRolloutPlanRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRolloutPlanRequest'->new($_) };

declare 'RepeatedInsertRolloutPlanRequest',
    as ArrayRef[InsertRolloutPlanRequest()];

coerce 'RepeatedInsertRolloutPlanRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRolloutPlanRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRolloutPlanRequest',
    as HashRef[InsertRolloutPlanRequest()];

declare 'InsertRouteRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRouteRequest'];

coerce 'InsertRouteRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRouteRequest'->new($_) };

declare 'RepeatedInsertRouteRequest',
    as ArrayRef[InsertRouteRequest()];

coerce 'RepeatedInsertRouteRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRouteRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRouteRequest',
    as HashRef[InsertRouteRequest()];

declare 'InsertRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertRouterRequest'];

coerce 'InsertRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertRouterRequest'->new($_) };

declare 'RepeatedInsertRouterRequest',
    as ArrayRef[InsertRouterRequest()];

coerce 'RepeatedInsertRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertRouterRequest'->new($_) } @$_ ] };

declare 'MapStringInsertRouterRequest',
    as HashRef[InsertRouterRequest()];

declare 'InsertSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertSecurityPolicyRequest'];

coerce 'InsertSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertSecurityPolicyRequest'->new($_) };

declare 'RepeatedInsertSecurityPolicyRequest',
    as ArrayRef[InsertSecurityPolicyRequest()];

coerce 'RepeatedInsertSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertSecurityPolicyRequest',
    as HashRef[InsertSecurityPolicyRequest()];

declare 'InsertServiceAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertServiceAttachmentRequest'];

coerce 'InsertServiceAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertServiceAttachmentRequest'->new($_) };

declare 'RepeatedInsertServiceAttachmentRequest',
    as ArrayRef[InsertServiceAttachmentRequest()];

coerce 'RepeatedInsertServiceAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertServiceAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringInsertServiceAttachmentRequest',
    as HashRef[InsertServiceAttachmentRequest()];

declare 'InsertSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertSnapshotRequest'];

coerce 'InsertSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertSnapshotRequest'->new($_) };

declare 'RepeatedInsertSnapshotRequest',
    as ArrayRef[InsertSnapshotRequest()];

coerce 'RepeatedInsertSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringInsertSnapshotRequest',
    as HashRef[InsertSnapshotRequest()];

declare 'InsertSslCertificateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertSslCertificateRequest'];

coerce 'InsertSslCertificateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertSslCertificateRequest'->new($_) };

declare 'RepeatedInsertSslCertificateRequest',
    as ArrayRef[InsertSslCertificateRequest()];

coerce 'RepeatedInsertSslCertificateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertSslCertificateRequest'->new($_) } @$_ ] };

declare 'MapStringInsertSslCertificateRequest',
    as HashRef[InsertSslCertificateRequest()];

declare 'InsertSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertSslPolicyRequest'];

coerce 'InsertSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertSslPolicyRequest'->new($_) };

declare 'RepeatedInsertSslPolicyRequest',
    as ArrayRef[InsertSslPolicyRequest()];

coerce 'RepeatedInsertSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertSslPolicyRequest',
    as HashRef[InsertSslPolicyRequest()];

declare 'InsertStoragePoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertStoragePoolRequest'];

coerce 'InsertStoragePoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertStoragePoolRequest'->new($_) };

declare 'RepeatedInsertStoragePoolRequest',
    as ArrayRef[InsertStoragePoolRequest()];

coerce 'RepeatedInsertStoragePoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertStoragePoolRequest'->new($_) } @$_ ] };

declare 'MapStringInsertStoragePoolRequest',
    as HashRef[InsertStoragePoolRequest()];

declare 'InsertSubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertSubnetworkRequest'];

coerce 'InsertSubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertSubnetworkRequest'->new($_) };

declare 'RepeatedInsertSubnetworkRequest',
    as ArrayRef[InsertSubnetworkRequest()];

coerce 'RepeatedInsertSubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertSubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringInsertSubnetworkRequest',
    as HashRef[InsertSubnetworkRequest()];

declare 'InsertTargetGrpcProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetGrpcProxyRequest'];

coerce 'InsertTargetGrpcProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetGrpcProxyRequest'->new($_) };

declare 'RepeatedInsertTargetGrpcProxyRequest',
    as ArrayRef[InsertTargetGrpcProxyRequest()];

coerce 'RepeatedInsertTargetGrpcProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetGrpcProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetGrpcProxyRequest',
    as HashRef[InsertTargetGrpcProxyRequest()];

declare 'InsertTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetHttpProxyRequest'];

coerce 'InsertTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetHttpProxyRequest'->new($_) };

declare 'RepeatedInsertTargetHttpProxyRequest',
    as ArrayRef[InsertTargetHttpProxyRequest()];

coerce 'RepeatedInsertTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetHttpProxyRequest',
    as HashRef[InsertTargetHttpProxyRequest()];

declare 'InsertTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetHttpsProxyRequest'];

coerce 'InsertTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedInsertTargetHttpsProxyRequest',
    as ArrayRef[InsertTargetHttpsProxyRequest()];

coerce 'RepeatedInsertTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetHttpsProxyRequest',
    as HashRef[InsertTargetHttpsProxyRequest()];

declare 'InsertTargetInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetInstanceRequest'];

coerce 'InsertTargetInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetInstanceRequest'->new($_) };

declare 'RepeatedInsertTargetInstanceRequest',
    as ArrayRef[InsertTargetInstanceRequest()];

coerce 'RepeatedInsertTargetInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetInstanceRequest',
    as HashRef[InsertTargetInstanceRequest()];

declare 'InsertTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetPoolRequest'];

coerce 'InsertTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetPoolRequest'->new($_) };

declare 'RepeatedInsertTargetPoolRequest',
    as ArrayRef[InsertTargetPoolRequest()];

coerce 'RepeatedInsertTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetPoolRequest',
    as HashRef[InsertTargetPoolRequest()];

declare 'InsertTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetSslProxyRequest'];

coerce 'InsertTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetSslProxyRequest'->new($_) };

declare 'RepeatedInsertTargetSslProxyRequest',
    as ArrayRef[InsertTargetSslProxyRequest()];

coerce 'RepeatedInsertTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetSslProxyRequest',
    as HashRef[InsertTargetSslProxyRequest()];

declare 'InsertTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetTcpProxyRequest'];

coerce 'InsertTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetTcpProxyRequest'->new($_) };

declare 'RepeatedInsertTargetTcpProxyRequest',
    as ArrayRef[InsertTargetTcpProxyRequest()];

coerce 'RepeatedInsertTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetTcpProxyRequest',
    as HashRef[InsertTargetTcpProxyRequest()];

declare 'InsertTargetVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertTargetVpnGatewayRequest'];

coerce 'InsertTargetVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertTargetVpnGatewayRequest'->new($_) };

declare 'RepeatedInsertTargetVpnGatewayRequest',
    as ArrayRef[InsertTargetVpnGatewayRequest()];

coerce 'RepeatedInsertTargetVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertTargetVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringInsertTargetVpnGatewayRequest',
    as HashRef[InsertTargetVpnGatewayRequest()];

declare 'InsertUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertUrlMapRequest'];

coerce 'InsertUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertUrlMapRequest'->new($_) };

declare 'RepeatedInsertUrlMapRequest',
    as ArrayRef[InsertUrlMapRequest()];

coerce 'RepeatedInsertUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringInsertUrlMapRequest',
    as HashRef[InsertUrlMapRequest()];

declare 'InsertVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertVpnGatewayRequest'];

coerce 'InsertVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertVpnGatewayRequest'->new($_) };

declare 'RepeatedInsertVpnGatewayRequest',
    as ArrayRef[InsertVpnGatewayRequest()];

coerce 'RepeatedInsertVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringInsertVpnGatewayRequest',
    as HashRef[InsertVpnGatewayRequest()];

declare 'InsertVpnTunnelRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertVpnTunnelRequest'];

coerce 'InsertVpnTunnelRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertVpnTunnelRequest'->new($_) };

declare 'RepeatedInsertVpnTunnelRequest',
    as ArrayRef[InsertVpnTunnelRequest()];

coerce 'RepeatedInsertVpnTunnelRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertVpnTunnelRequest'->new($_) } @$_ ] };

declare 'MapStringInsertVpnTunnelRequest',
    as HashRef[InsertVpnTunnelRequest()];

declare 'InsertWireGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertWireGroupRequest'];

coerce 'InsertWireGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertWireGroupRequest'->new($_) };

declare 'RepeatedInsertWireGroupRequest',
    as ArrayRef[InsertWireGroupRequest()];

coerce 'RepeatedInsertWireGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertWireGroupRequest'->new($_) } @$_ ] };

declare 'MapStringInsertWireGroupRequest',
    as HashRef[InsertWireGroupRequest()];

declare 'InsertZoneVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InsertZoneVmExtensionPolicyRequest'];

coerce 'InsertZoneVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InsertZoneVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedInsertZoneVmExtensionPolicyRequest',
    as ArrayRef[InsertZoneVmExtensionPolicyRequest()];

coerce 'RepeatedInsertZoneVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InsertZoneVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInsertZoneVmExtensionPolicyRequest',
    as HashRef[InsertZoneVmExtensionPolicyRequest()];

declare 'Instance',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Instance'];

coerce 'Instance',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Instance'->new($_) };

declare 'RepeatedInstance',
    as ArrayRef[Instance()];

coerce 'RepeatedInstance',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Instance'->new($_) } @$_ ] };

declare 'MapStringInstance',
    as HashRef[Instance()];

declare 'KeyRevocationActionType',
    as (Int | Str);

declare 'LocalSsdEncryptionMode',
    as (Int | Str);

declare 'PrivateIpv6GoogleAccess',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Instance::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Instance::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Instance::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'InstanceAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceAggregatedList'];

coerce 'InstanceAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceAggregatedList'->new($_) };

declare 'RepeatedInstanceAggregatedList',
    as ArrayRef[InstanceAggregatedList()];

coerce 'RepeatedInstanceAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceAggregatedList'->new($_) } @$_ ] };

declare 'MapStringInstanceAggregatedList',
    as HashRef[InstanceAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'InstanceConsumptionData',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceConsumptionData'];

coerce 'InstanceConsumptionData',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceConsumptionData'->new($_) };

declare 'RepeatedInstanceConsumptionData',
    as ArrayRef[InstanceConsumptionData()];

coerce 'RepeatedInstanceConsumptionData',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceConsumptionData'->new($_) } @$_ ] };

declare 'MapStringInstanceConsumptionData',
    as HashRef[InstanceConsumptionData()];

declare 'InstanceConsumptionInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceConsumptionInfo'];

coerce 'InstanceConsumptionInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceConsumptionInfo'->new($_) };

declare 'RepeatedInstanceConsumptionInfo',
    as ArrayRef[InstanceConsumptionInfo()];

coerce 'RepeatedInstanceConsumptionInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceConsumptionInfo'->new($_) } @$_ ] };

declare 'MapStringInstanceConsumptionInfo',
    as HashRef[InstanceConsumptionInfo()];

declare 'InstanceFlexibilityPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicy'];

coerce 'InstanceFlexibilityPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicy'->new($_) };

declare 'RepeatedInstanceFlexibilityPolicy',
    as ArrayRef[InstanceFlexibilityPolicy()];

coerce 'RepeatedInstanceFlexibilityPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicy'->new($_) } @$_ ] };

declare 'MapStringInstanceFlexibilityPolicy',
    as HashRef[InstanceFlexibilityPolicy()];

declare 'InstanceSelectionsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicy::InstanceSelectionsEntry'];

coerce 'InstanceSelectionsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicy::InstanceSelectionsEntry'->new($_) };

declare 'RepeatedInstanceSelectionsEntry',
    as ArrayRef[InstanceSelectionsEntry()];

coerce 'RepeatedInstanceSelectionsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicy::InstanceSelectionsEntry'->new($_) } @$_ ] };

declare 'MapStringInstanceSelectionsEntry',
    as HashRef[InstanceSelectionsEntry()];

declare 'InstanceFlexibilityPolicyInstanceSelection',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicyInstanceSelection'];

coerce 'InstanceFlexibilityPolicyInstanceSelection',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicyInstanceSelection'->new($_) };

declare 'RepeatedInstanceFlexibilityPolicyInstanceSelection',
    as ArrayRef[InstanceFlexibilityPolicyInstanceSelection()];

coerce 'RepeatedInstanceFlexibilityPolicyInstanceSelection',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceFlexibilityPolicyInstanceSelection'->new($_) } @$_ ] };

declare 'MapStringInstanceFlexibilityPolicyInstanceSelection',
    as HashRef[InstanceFlexibilityPolicyInstanceSelection()];

declare 'InstanceGroup',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroup'];

coerce 'InstanceGroup',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroup'->new($_) };

declare 'RepeatedInstanceGroup',
    as ArrayRef[InstanceGroup()];

coerce 'RepeatedInstanceGroup',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroup'->new($_) } @$_ ] };

declare 'MapStringInstanceGroup',
    as HashRef[InstanceGroup()];

declare 'InstanceGroupAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupAggregatedList'];

coerce 'InstanceGroupAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupAggregatedList'->new($_) };

declare 'RepeatedInstanceGroupAggregatedList',
    as ArrayRef[InstanceGroupAggregatedList()];

coerce 'RepeatedInstanceGroupAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupAggregatedList'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupAggregatedList',
    as HashRef[InstanceGroupAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'InstanceGroupList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupList'];

coerce 'InstanceGroupList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupList'->new($_) };

declare 'RepeatedInstanceGroupList',
    as ArrayRef[InstanceGroupList()];

coerce 'RepeatedInstanceGroupList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupList'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupList',
    as HashRef[InstanceGroupList()];

declare 'InstanceGroupManager',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManager'];

coerce 'InstanceGroupManager',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManager'->new($_) };

declare 'RepeatedInstanceGroupManager',
    as ArrayRef[InstanceGroupManager()];

coerce 'RepeatedInstanceGroupManager',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManager'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManager',
    as HashRef[InstanceGroupManager()];

declare 'ListManagedInstancesResults',
    as (Int | Str);

declare 'InstanceGroupManagerActionsSummary',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerActionsSummary'];

coerce 'InstanceGroupManagerActionsSummary',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerActionsSummary'->new($_) };

declare 'RepeatedInstanceGroupManagerActionsSummary',
    as ArrayRef[InstanceGroupManagerActionsSummary()];

coerce 'RepeatedInstanceGroupManagerActionsSummary',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerActionsSummary'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerActionsSummary',
    as HashRef[InstanceGroupManagerActionsSummary()];

declare 'InstanceGroupManagerAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAggregatedList'];

coerce 'InstanceGroupManagerAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAggregatedList'->new($_) };

declare 'RepeatedInstanceGroupManagerAggregatedList',
    as ArrayRef[InstanceGroupManagerAggregatedList()];

coerce 'RepeatedInstanceGroupManagerAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAggregatedList'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerAggregatedList',
    as HashRef[InstanceGroupManagerAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'InstanceGroupManagerAllInstancesConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAllInstancesConfig'];

coerce 'InstanceGroupManagerAllInstancesConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAllInstancesConfig'->new($_) };

declare 'RepeatedInstanceGroupManagerAllInstancesConfig',
    as ArrayRef[InstanceGroupManagerAllInstancesConfig()];

coerce 'RepeatedInstanceGroupManagerAllInstancesConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAllInstancesConfig'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerAllInstancesConfig',
    as HashRef[InstanceGroupManagerAllInstancesConfig()];

declare 'InstanceGroupManagerAutoHealingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAutoHealingPolicy'];

coerce 'InstanceGroupManagerAutoHealingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAutoHealingPolicy'->new($_) };

declare 'RepeatedInstanceGroupManagerAutoHealingPolicy',
    as ArrayRef[InstanceGroupManagerAutoHealingPolicy()];

coerce 'RepeatedInstanceGroupManagerAutoHealingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerAutoHealingPolicy'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerAutoHealingPolicy',
    as HashRef[InstanceGroupManagerAutoHealingPolicy()];

declare 'InstanceGroupManagerInstanceFlexibilityPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicy'];

coerce 'InstanceGroupManagerInstanceFlexibilityPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicy'->new($_) };

declare 'RepeatedInstanceGroupManagerInstanceFlexibilityPolicy',
    as ArrayRef[InstanceGroupManagerInstanceFlexibilityPolicy()];

coerce 'RepeatedInstanceGroupManagerInstanceFlexibilityPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicy'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerInstanceFlexibilityPolicy',
    as HashRef[InstanceGroupManagerInstanceFlexibilityPolicy()];

declare 'InstanceSelectionsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicy::InstanceSelectionsEntry'];

coerce 'InstanceSelectionsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicy::InstanceSelectionsEntry'->new($_) };

declare 'RepeatedInstanceSelectionsEntry',
    as ArrayRef[InstanceSelectionsEntry()];

coerce 'RepeatedInstanceSelectionsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicy::InstanceSelectionsEntry'->new($_) } @$_ ] };

declare 'MapStringInstanceSelectionsEntry',
    as HashRef[InstanceSelectionsEntry()];

declare 'InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection'];

coerce 'InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection'->new($_) };

declare 'RepeatedInstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection',
    as ArrayRef[InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection()];

coerce 'RepeatedInstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection',
    as HashRef[InstanceGroupManagerInstanceFlexibilityPolicyInstanceSelection()];

declare 'InstanceGroupManagerInstanceLifecyclePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceLifecyclePolicy'];

coerce 'InstanceGroupManagerInstanceLifecyclePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceLifecyclePolicy'->new($_) };

declare 'RepeatedInstanceGroupManagerInstanceLifecyclePolicy',
    as ArrayRef[InstanceGroupManagerInstanceLifecyclePolicy()];

coerce 'RepeatedInstanceGroupManagerInstanceLifecyclePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceLifecyclePolicy'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerInstanceLifecyclePolicy',
    as HashRef[InstanceGroupManagerInstanceLifecyclePolicy()];

declare 'DefaultActionOnFailure',
    as (Int | Str);

declare 'ForceUpdateOnRepair',
    as (Int | Str);

declare 'OnFailedHealthCheck',
    as (Int | Str);

declare 'InstanceGroupManagerInstanceLifecyclePolicyOnRepair',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceLifecyclePolicyOnRepair'];

coerce 'InstanceGroupManagerInstanceLifecyclePolicyOnRepair',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceLifecyclePolicyOnRepair'->new($_) };

declare 'RepeatedInstanceGroupManagerInstanceLifecyclePolicyOnRepair',
    as ArrayRef[InstanceGroupManagerInstanceLifecyclePolicyOnRepair()];

coerce 'RepeatedInstanceGroupManagerInstanceLifecyclePolicyOnRepair',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerInstanceLifecyclePolicyOnRepair'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerInstanceLifecyclePolicyOnRepair',
    as HashRef[InstanceGroupManagerInstanceLifecyclePolicyOnRepair()];

declare 'AllowChangingZone',
    as (Int | Str);

declare 'InstanceGroupManagerList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerList'];

coerce 'InstanceGroupManagerList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerList'->new($_) };

declare 'RepeatedInstanceGroupManagerList',
    as ArrayRef[InstanceGroupManagerList()];

coerce 'RepeatedInstanceGroupManagerList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerList'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerList',
    as HashRef[InstanceGroupManagerList()];

declare 'InstanceGroupManagerResizeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequest'];

coerce 'InstanceGroupManagerResizeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequest'->new($_) };

declare 'RepeatedInstanceGroupManagerResizeRequest',
    as ArrayRef[InstanceGroupManagerResizeRequest()];

coerce 'RepeatedInstanceGroupManagerResizeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerResizeRequest',
    as HashRef[InstanceGroupManagerResizeRequest()];

declare 'State',
    as (Int | Str);

declare 'InstanceGroupManagerResizeRequestStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestStatus'];

coerce 'InstanceGroupManagerResizeRequestStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestStatus'->new($_) };

declare 'RepeatedInstanceGroupManagerResizeRequestStatus',
    as ArrayRef[InstanceGroupManagerResizeRequestStatus()];

coerce 'RepeatedInstanceGroupManagerResizeRequestStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestStatus'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerResizeRequestStatus',
    as HashRef[InstanceGroupManagerResizeRequestStatus()];

declare 'InstanceGroupManagerResizeRequestStatusLastAttempt',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestStatusLastAttempt'];

coerce 'InstanceGroupManagerResizeRequestStatusLastAttempt',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestStatusLastAttempt'->new($_) };

declare 'RepeatedInstanceGroupManagerResizeRequestStatusLastAttempt',
    as ArrayRef[InstanceGroupManagerResizeRequestStatusLastAttempt()];

coerce 'RepeatedInstanceGroupManagerResizeRequestStatusLastAttempt',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestStatusLastAttempt'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerResizeRequestStatusLastAttempt',
    as HashRef[InstanceGroupManagerResizeRequestStatusLastAttempt()];

declare 'InstanceGroupManagerResizeRequestsListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestsListResponse'];

coerce 'InstanceGroupManagerResizeRequestsListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestsListResponse'->new($_) };

declare 'RepeatedInstanceGroupManagerResizeRequestsListResponse',
    as ArrayRef[InstanceGroupManagerResizeRequestsListResponse()];

coerce 'RepeatedInstanceGroupManagerResizeRequestsListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResizeRequestsListResponse'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerResizeRequestsListResponse',
    as HashRef[InstanceGroupManagerResizeRequestsListResponse()];

declare 'InstanceGroupManagerResourcePolicies',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResourcePolicies'];

coerce 'InstanceGroupManagerResourcePolicies',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResourcePolicies'->new($_) };

declare 'RepeatedInstanceGroupManagerResourcePolicies',
    as ArrayRef[InstanceGroupManagerResourcePolicies()];

coerce 'RepeatedInstanceGroupManagerResourcePolicies',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerResourcePolicies'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerResourcePolicies',
    as HashRef[InstanceGroupManagerResourcePolicies()];

declare 'InstanceGroupManagerStandbyPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStandbyPolicy'];

coerce 'InstanceGroupManagerStandbyPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStandbyPolicy'->new($_) };

declare 'RepeatedInstanceGroupManagerStandbyPolicy',
    as ArrayRef[InstanceGroupManagerStandbyPolicy()];

coerce 'RepeatedInstanceGroupManagerStandbyPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStandbyPolicy'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStandbyPolicy',
    as HashRef[InstanceGroupManagerStandbyPolicy()];

declare 'Mode',
    as (Int | Str);

declare 'InstanceGroupManagerStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatus'];

coerce 'InstanceGroupManagerStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatus'->new($_) };

declare 'RepeatedInstanceGroupManagerStatus',
    as ArrayRef[InstanceGroupManagerStatus()];

coerce 'RepeatedInstanceGroupManagerStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatus'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatus',
    as HashRef[InstanceGroupManagerStatus()];

declare 'InstanceGroupManagerStatusAcceleratorTopology',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAcceleratorTopology'];

coerce 'InstanceGroupManagerStatusAcceleratorTopology',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAcceleratorTopology'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusAcceleratorTopology',
    as ArrayRef[InstanceGroupManagerStatusAcceleratorTopology()];

coerce 'RepeatedInstanceGroupManagerStatusAcceleratorTopology',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAcceleratorTopology'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusAcceleratorTopology',
    as HashRef[InstanceGroupManagerStatusAcceleratorTopology()];

declare 'State',
    as (Int | Str);

declare 'InstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails'];

coerce 'InstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails',
    as ArrayRef[InstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails()];

coerce 'RepeatedInstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails',
    as HashRef[InstanceGroupManagerStatusAcceleratorTopologyAcceleratorTopologyStateDetails()];

declare 'InstanceGroupManagerStatusAllInstancesConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAllInstancesConfig'];

coerce 'InstanceGroupManagerStatusAllInstancesConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAllInstancesConfig'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusAllInstancesConfig',
    as ArrayRef[InstanceGroupManagerStatusAllInstancesConfig()];

coerce 'RepeatedInstanceGroupManagerStatusAllInstancesConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusAllInstancesConfig'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusAllInstancesConfig',
    as HashRef[InstanceGroupManagerStatusAllInstancesConfig()];

declare 'InstanceGroupManagerStatusBulkInstanceOperation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusBulkInstanceOperation'];

coerce 'InstanceGroupManagerStatusBulkInstanceOperation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusBulkInstanceOperation'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusBulkInstanceOperation',
    as ArrayRef[InstanceGroupManagerStatusBulkInstanceOperation()];

coerce 'RepeatedInstanceGroupManagerStatusBulkInstanceOperation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusBulkInstanceOperation'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusBulkInstanceOperation',
    as HashRef[InstanceGroupManagerStatusBulkInstanceOperation()];

declare 'InstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck'];

coerce 'InstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck',
    as ArrayRef[InstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck()];

coerce 'RepeatedInstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck',
    as HashRef[InstanceGroupManagerStatusBulkInstanceOperationLastProgressCheck()];

declare 'InstanceGroupManagerStatusInstanceStatusSummary',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusInstanceStatusSummary'];

coerce 'InstanceGroupManagerStatusInstanceStatusSummary',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusInstanceStatusSummary'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusInstanceStatusSummary',
    as ArrayRef[InstanceGroupManagerStatusInstanceStatusSummary()];

coerce 'RepeatedInstanceGroupManagerStatusInstanceStatusSummary',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusInstanceStatusSummary'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusInstanceStatusSummary',
    as HashRef[InstanceGroupManagerStatusInstanceStatusSummary()];

declare 'InstanceGroupManagerStatusStateful',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusStateful'];

coerce 'InstanceGroupManagerStatusStateful',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusStateful'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusStateful',
    as ArrayRef[InstanceGroupManagerStatusStateful()];

coerce 'RepeatedInstanceGroupManagerStatusStateful',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusStateful'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusStateful',
    as HashRef[InstanceGroupManagerStatusStateful()];

declare 'InstanceGroupManagerStatusStatefulPerInstanceConfigs',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusStatefulPerInstanceConfigs'];

coerce 'InstanceGroupManagerStatusStatefulPerInstanceConfigs',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusStatefulPerInstanceConfigs'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusStatefulPerInstanceConfigs',
    as ArrayRef[InstanceGroupManagerStatusStatefulPerInstanceConfigs()];

coerce 'RepeatedInstanceGroupManagerStatusStatefulPerInstanceConfigs',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusStatefulPerInstanceConfigs'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusStatefulPerInstanceConfigs',
    as HashRef[InstanceGroupManagerStatusStatefulPerInstanceConfigs()];

declare 'InstanceGroupManagerStatusVersionTarget',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusVersionTarget'];

coerce 'InstanceGroupManagerStatusVersionTarget',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusVersionTarget'->new($_) };

declare 'RepeatedInstanceGroupManagerStatusVersionTarget',
    as ArrayRef[InstanceGroupManagerStatusVersionTarget()];

coerce 'RepeatedInstanceGroupManagerStatusVersionTarget',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerStatusVersionTarget'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerStatusVersionTarget',
    as HashRef[InstanceGroupManagerStatusVersionTarget()];

declare 'InstanceGroupManagerTargetSizePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerTargetSizePolicy'];

coerce 'InstanceGroupManagerTargetSizePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerTargetSizePolicy'->new($_) };

declare 'RepeatedInstanceGroupManagerTargetSizePolicy',
    as ArrayRef[InstanceGroupManagerTargetSizePolicy()];

coerce 'RepeatedInstanceGroupManagerTargetSizePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerTargetSizePolicy'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerTargetSizePolicy',
    as HashRef[InstanceGroupManagerTargetSizePolicy()];

declare 'Mode',
    as (Int | Str);

declare 'InstanceGroupManagerUpdatePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerUpdatePolicy'];

coerce 'InstanceGroupManagerUpdatePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerUpdatePolicy'->new($_) };

declare 'RepeatedInstanceGroupManagerUpdatePolicy',
    as ArrayRef[InstanceGroupManagerUpdatePolicy()];

coerce 'RepeatedInstanceGroupManagerUpdatePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerUpdatePolicy'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerUpdatePolicy',
    as HashRef[InstanceGroupManagerUpdatePolicy()];

declare 'InstanceRedistributionType',
    as (Int | Str);

declare 'MinimalAction',
    as (Int | Str);

declare 'MostDisruptiveAllowedAction',
    as (Int | Str);

declare 'ReplacementMethod',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'InstanceGroupManagerVersion',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagerVersion'];

coerce 'InstanceGroupManagerVersion',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerVersion'->new($_) };

declare 'RepeatedInstanceGroupManagerVersion',
    as ArrayRef[InstanceGroupManagerVersion()];

coerce 'RepeatedInstanceGroupManagerVersion',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagerVersion'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagerVersion',
    as HashRef[InstanceGroupManagerVersion()];

declare 'InstanceGroupManagersAbandonInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersAbandonInstancesRequest'];

coerce 'InstanceGroupManagersAbandonInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersAbandonInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersAbandonInstancesRequest',
    as ArrayRef[InstanceGroupManagersAbandonInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersAbandonInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersAbandonInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersAbandonInstancesRequest',
    as HashRef[InstanceGroupManagersAbandonInstancesRequest()];

declare 'InstanceGroupManagersApplyUpdatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersApplyUpdatesRequest'];

coerce 'InstanceGroupManagersApplyUpdatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersApplyUpdatesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersApplyUpdatesRequest',
    as ArrayRef[InstanceGroupManagersApplyUpdatesRequest()];

coerce 'RepeatedInstanceGroupManagersApplyUpdatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersApplyUpdatesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersApplyUpdatesRequest',
    as HashRef[InstanceGroupManagersApplyUpdatesRequest()];

declare 'MinimalAction',
    as (Int | Str);

declare 'MostDisruptiveAllowedAction',
    as (Int | Str);

declare 'InstanceGroupManagersCreateInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersCreateInstancesRequest'];

coerce 'InstanceGroupManagersCreateInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersCreateInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersCreateInstancesRequest',
    as ArrayRef[InstanceGroupManagersCreateInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersCreateInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersCreateInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersCreateInstancesRequest',
    as HashRef[InstanceGroupManagersCreateInstancesRequest()];

declare 'InstanceGroupManagersDeleteInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersDeleteInstancesRequest'];

coerce 'InstanceGroupManagersDeleteInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersDeleteInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersDeleteInstancesRequest',
    as ArrayRef[InstanceGroupManagersDeleteInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersDeleteInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersDeleteInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersDeleteInstancesRequest',
    as HashRef[InstanceGroupManagersDeleteInstancesRequest()];

declare 'InstanceGroupManagersDeletePerInstanceConfigsReq',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersDeletePerInstanceConfigsReq'];

coerce 'InstanceGroupManagersDeletePerInstanceConfigsReq',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersDeletePerInstanceConfigsReq'->new($_) };

declare 'RepeatedInstanceGroupManagersDeletePerInstanceConfigsReq',
    as ArrayRef[InstanceGroupManagersDeletePerInstanceConfigsReq()];

coerce 'RepeatedInstanceGroupManagersDeletePerInstanceConfigsReq',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersDeletePerInstanceConfigsReq'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersDeletePerInstanceConfigsReq',
    as HashRef[InstanceGroupManagersDeletePerInstanceConfigsReq()];

declare 'InstanceGroupManagersListErrorsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListErrorsResponse'];

coerce 'InstanceGroupManagersListErrorsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListErrorsResponse'->new($_) };

declare 'RepeatedInstanceGroupManagersListErrorsResponse',
    as ArrayRef[InstanceGroupManagersListErrorsResponse()];

coerce 'RepeatedInstanceGroupManagersListErrorsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListErrorsResponse'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersListErrorsResponse',
    as HashRef[InstanceGroupManagersListErrorsResponse()];

declare 'InstanceGroupManagersListManagedInstancesResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListManagedInstancesResponse'];

coerce 'InstanceGroupManagersListManagedInstancesResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListManagedInstancesResponse'->new($_) };

declare 'RepeatedInstanceGroupManagersListManagedInstancesResponse',
    as ArrayRef[InstanceGroupManagersListManagedInstancesResponse()];

coerce 'RepeatedInstanceGroupManagersListManagedInstancesResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListManagedInstancesResponse'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersListManagedInstancesResponse',
    as HashRef[InstanceGroupManagersListManagedInstancesResponse()];

declare 'InstanceGroupManagersListPerInstanceConfigsResp',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListPerInstanceConfigsResp'];

coerce 'InstanceGroupManagersListPerInstanceConfigsResp',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListPerInstanceConfigsResp'->new($_) };

declare 'RepeatedInstanceGroupManagersListPerInstanceConfigsResp',
    as ArrayRef[InstanceGroupManagersListPerInstanceConfigsResp()];

coerce 'RepeatedInstanceGroupManagersListPerInstanceConfigsResp',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersListPerInstanceConfigsResp'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersListPerInstanceConfigsResp',
    as HashRef[InstanceGroupManagersListPerInstanceConfigsResp()];

declare 'InstanceGroupManagersPatchPerInstanceConfigsReq',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersPatchPerInstanceConfigsReq'];

coerce 'InstanceGroupManagersPatchPerInstanceConfigsReq',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersPatchPerInstanceConfigsReq'->new($_) };

declare 'RepeatedInstanceGroupManagersPatchPerInstanceConfigsReq',
    as ArrayRef[InstanceGroupManagersPatchPerInstanceConfigsReq()];

coerce 'RepeatedInstanceGroupManagersPatchPerInstanceConfigsReq',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersPatchPerInstanceConfigsReq'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersPatchPerInstanceConfigsReq',
    as HashRef[InstanceGroupManagersPatchPerInstanceConfigsReq()];

declare 'InstanceGroupManagersRecreateInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersRecreateInstancesRequest'];

coerce 'InstanceGroupManagersRecreateInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersRecreateInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersRecreateInstancesRequest',
    as ArrayRef[InstanceGroupManagersRecreateInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersRecreateInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersRecreateInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersRecreateInstancesRequest',
    as HashRef[InstanceGroupManagersRecreateInstancesRequest()];

declare 'InstanceGroupManagersResumeInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersResumeInstancesRequest'];

coerce 'InstanceGroupManagersResumeInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersResumeInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersResumeInstancesRequest',
    as ArrayRef[InstanceGroupManagersResumeInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersResumeInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersResumeInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersResumeInstancesRequest',
    as HashRef[InstanceGroupManagersResumeInstancesRequest()];

declare 'InstanceGroupManagersScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersScopedList'];

coerce 'InstanceGroupManagersScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersScopedList'->new($_) };

declare 'RepeatedInstanceGroupManagersScopedList',
    as ArrayRef[InstanceGroupManagersScopedList()];

coerce 'RepeatedInstanceGroupManagersScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersScopedList'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersScopedList',
    as HashRef[InstanceGroupManagersScopedList()];

declare 'InstanceGroupManagersSetInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSetInstanceTemplateRequest'];

coerce 'InstanceGroupManagersSetInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSetInstanceTemplateRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersSetInstanceTemplateRequest',
    as ArrayRef[InstanceGroupManagersSetInstanceTemplateRequest()];

coerce 'RepeatedInstanceGroupManagersSetInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSetInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersSetInstanceTemplateRequest',
    as HashRef[InstanceGroupManagersSetInstanceTemplateRequest()];

declare 'InstanceGroupManagersSetTargetPoolsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSetTargetPoolsRequest'];

coerce 'InstanceGroupManagersSetTargetPoolsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSetTargetPoolsRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersSetTargetPoolsRequest',
    as ArrayRef[InstanceGroupManagersSetTargetPoolsRequest()];

coerce 'RepeatedInstanceGroupManagersSetTargetPoolsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSetTargetPoolsRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersSetTargetPoolsRequest',
    as HashRef[InstanceGroupManagersSetTargetPoolsRequest()];

declare 'InstanceGroupManagersStartInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersStartInstancesRequest'];

coerce 'InstanceGroupManagersStartInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersStartInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersStartInstancesRequest',
    as ArrayRef[InstanceGroupManagersStartInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersStartInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersStartInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersStartInstancesRequest',
    as HashRef[InstanceGroupManagersStartInstancesRequest()];

declare 'InstanceGroupManagersStopInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersStopInstancesRequest'];

coerce 'InstanceGroupManagersStopInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersStopInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersStopInstancesRequest',
    as ArrayRef[InstanceGroupManagersStopInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersStopInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersStopInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersStopInstancesRequest',
    as HashRef[InstanceGroupManagersStopInstancesRequest()];

declare 'InstanceGroupManagersSuspendInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSuspendInstancesRequest'];

coerce 'InstanceGroupManagersSuspendInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSuspendInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupManagersSuspendInstancesRequest',
    as ArrayRef[InstanceGroupManagersSuspendInstancesRequest()];

coerce 'RepeatedInstanceGroupManagersSuspendInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersSuspendInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersSuspendInstancesRequest',
    as HashRef[InstanceGroupManagersSuspendInstancesRequest()];

declare 'InstanceGroupManagersUpdatePerInstanceConfigsReq',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupManagersUpdatePerInstanceConfigsReq'];

coerce 'InstanceGroupManagersUpdatePerInstanceConfigsReq',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersUpdatePerInstanceConfigsReq'->new($_) };

declare 'RepeatedInstanceGroupManagersUpdatePerInstanceConfigsReq',
    as ArrayRef[InstanceGroupManagersUpdatePerInstanceConfigsReq()];

coerce 'RepeatedInstanceGroupManagersUpdatePerInstanceConfigsReq',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupManagersUpdatePerInstanceConfigsReq'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupManagersUpdatePerInstanceConfigsReq',
    as HashRef[InstanceGroupManagersUpdatePerInstanceConfigsReq()];

declare 'InstanceGroupsAddInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupsAddInstancesRequest'];

coerce 'InstanceGroupsAddInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsAddInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupsAddInstancesRequest',
    as ArrayRef[InstanceGroupsAddInstancesRequest()];

coerce 'RepeatedInstanceGroupsAddInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsAddInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupsAddInstancesRequest',
    as HashRef[InstanceGroupsAddInstancesRequest()];

declare 'InstanceGroupsListInstances',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupsListInstances'];

coerce 'InstanceGroupsListInstances',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsListInstances'->new($_) };

declare 'RepeatedInstanceGroupsListInstances',
    as ArrayRef[InstanceGroupsListInstances()];

coerce 'RepeatedInstanceGroupsListInstances',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsListInstances'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupsListInstances',
    as HashRef[InstanceGroupsListInstances()];

declare 'InstanceGroupsListInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupsListInstancesRequest'];

coerce 'InstanceGroupsListInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsListInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupsListInstancesRequest',
    as ArrayRef[InstanceGroupsListInstancesRequest()];

coerce 'RepeatedInstanceGroupsListInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsListInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupsListInstancesRequest',
    as HashRef[InstanceGroupsListInstancesRequest()];

declare 'InstanceState',
    as (Int | Str);

declare 'InstanceGroupsRemoveInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupsRemoveInstancesRequest'];

coerce 'InstanceGroupsRemoveInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsRemoveInstancesRequest'->new($_) };

declare 'RepeatedInstanceGroupsRemoveInstancesRequest',
    as ArrayRef[InstanceGroupsRemoveInstancesRequest()];

coerce 'RepeatedInstanceGroupsRemoveInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsRemoveInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupsRemoveInstancesRequest',
    as HashRef[InstanceGroupsRemoveInstancesRequest()];

declare 'InstanceGroupsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupsScopedList'];

coerce 'InstanceGroupsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsScopedList'->new($_) };

declare 'RepeatedInstanceGroupsScopedList',
    as ArrayRef[InstanceGroupsScopedList()];

coerce 'RepeatedInstanceGroupsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsScopedList'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupsScopedList',
    as HashRef[InstanceGroupsScopedList()];

declare 'InstanceGroupsSetNamedPortsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceGroupsSetNamedPortsRequest'];

coerce 'InstanceGroupsSetNamedPortsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsSetNamedPortsRequest'->new($_) };

declare 'RepeatedInstanceGroupsSetNamedPortsRequest',
    as ArrayRef[InstanceGroupsSetNamedPortsRequest()];

coerce 'RepeatedInstanceGroupsSetNamedPortsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceGroupsSetNamedPortsRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceGroupsSetNamedPortsRequest',
    as HashRef[InstanceGroupsSetNamedPortsRequest()];

declare 'InstanceList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceList'];

coerce 'InstanceList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceList'->new($_) };

declare 'RepeatedInstanceList',
    as ArrayRef[InstanceList()];

coerce 'RepeatedInstanceList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceList'->new($_) } @$_ ] };

declare 'MapStringInstanceList',
    as HashRef[InstanceList()];

declare 'InstanceListReferrers',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceListReferrers'];

coerce 'InstanceListReferrers',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceListReferrers'->new($_) };

declare 'RepeatedInstanceListReferrers',
    as ArrayRef[InstanceListReferrers()];

coerce 'RepeatedInstanceListReferrers',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceListReferrers'->new($_) } @$_ ] };

declare 'MapStringInstanceListReferrers',
    as HashRef[InstanceListReferrers()];

declare 'InstanceManagedByIgmError',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmError'];

coerce 'InstanceManagedByIgmError',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmError'->new($_) };

declare 'RepeatedInstanceManagedByIgmError',
    as ArrayRef[InstanceManagedByIgmError()];

coerce 'RepeatedInstanceManagedByIgmError',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmError'->new($_) } @$_ ] };

declare 'MapStringInstanceManagedByIgmError',
    as HashRef[InstanceManagedByIgmError()];

declare 'InstanceManagedByIgmErrorInstanceActionDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmErrorInstanceActionDetails'];

coerce 'InstanceManagedByIgmErrorInstanceActionDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmErrorInstanceActionDetails'->new($_) };

declare 'RepeatedInstanceManagedByIgmErrorInstanceActionDetails',
    as ArrayRef[InstanceManagedByIgmErrorInstanceActionDetails()];

coerce 'RepeatedInstanceManagedByIgmErrorInstanceActionDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmErrorInstanceActionDetails'->new($_) } @$_ ] };

declare 'MapStringInstanceManagedByIgmErrorInstanceActionDetails',
    as HashRef[InstanceManagedByIgmErrorInstanceActionDetails()];

declare 'Action',
    as (Int | Str);

declare 'InstanceManagedByIgmErrorManagedInstanceError',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmErrorManagedInstanceError'];

coerce 'InstanceManagedByIgmErrorManagedInstanceError',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmErrorManagedInstanceError'->new($_) };

declare 'RepeatedInstanceManagedByIgmErrorManagedInstanceError',
    as ArrayRef[InstanceManagedByIgmErrorManagedInstanceError()];

coerce 'RepeatedInstanceManagedByIgmErrorManagedInstanceError',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceManagedByIgmErrorManagedInstanceError'->new($_) } @$_ ] };

declare 'MapStringInstanceManagedByIgmErrorManagedInstanceError',
    as HashRef[InstanceManagedByIgmErrorManagedInstanceError()];

declare 'InstanceMoveRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceMoveRequest'];

coerce 'InstanceMoveRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceMoveRequest'->new($_) };

declare 'RepeatedInstanceMoveRequest',
    as ArrayRef[InstanceMoveRequest()];

coerce 'RepeatedInstanceMoveRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceMoveRequest'->new($_) } @$_ ] };

declare 'MapStringInstanceMoveRequest',
    as HashRef[InstanceMoveRequest()];

declare 'InstanceParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceParams'];

coerce 'InstanceParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceParams'->new($_) };

declare 'RepeatedInstanceParams',
    as ArrayRef[InstanceParams()];

coerce 'RepeatedInstanceParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceParams'->new($_) } @$_ ] };

declare 'MapStringInstanceParams',
    as HashRef[InstanceParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'InstanceProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceProperties'];

coerce 'InstanceProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceProperties'->new($_) };

declare 'RepeatedInstanceProperties',
    as ArrayRef[InstanceProperties()];

coerce 'RepeatedInstanceProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceProperties'->new($_) } @$_ ] };

declare 'MapStringInstanceProperties',
    as HashRef[InstanceProperties()];

declare 'KeyRevocationActionType',
    as (Int | Str);

declare 'LocalSsdEncryptionMode',
    as (Int | Str);

declare 'PrivateIpv6GoogleAccess',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceProperties::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceProperties::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceProperties::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceProperties::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceProperties::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceProperties::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'InstancePropertiesPatch',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch'];

coerce 'InstancePropertiesPatch',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch'->new($_) };

declare 'RepeatedInstancePropertiesPatch',
    as ArrayRef[InstancePropertiesPatch()];

coerce 'RepeatedInstancePropertiesPatch',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch'->new($_) } @$_ ] };

declare 'MapStringInstancePropertiesPatch',
    as HashRef[InstancePropertiesPatch()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'MetadataEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch::MetadataEntry'];

coerce 'MetadataEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch::MetadataEntry'->new($_) };

declare 'RepeatedMetadataEntry',
    as ArrayRef[MetadataEntry()];

coerce 'RepeatedMetadataEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancePropertiesPatch::MetadataEntry'->new($_) } @$_ ] };

declare 'MapStringMetadataEntry',
    as HashRef[MetadataEntry()];

declare 'InstanceReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceReference'];

coerce 'InstanceReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceReference'->new($_) };

declare 'RepeatedInstanceReference',
    as ArrayRef[InstanceReference()];

coerce 'RepeatedInstanceReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceReference'->new($_) } @$_ ] };

declare 'MapStringInstanceReference',
    as HashRef[InstanceReference()];

declare 'InstanceSettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceSettings'];

coerce 'InstanceSettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceSettings'->new($_) };

declare 'RepeatedInstanceSettings',
    as ArrayRef[InstanceSettings()];

coerce 'RepeatedInstanceSettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceSettings'->new($_) } @$_ ] };

declare 'MapStringInstanceSettings',
    as HashRef[InstanceSettings()];

declare 'InstanceSettingsMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceSettingsMetadata'];

coerce 'InstanceSettingsMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceSettingsMetadata'->new($_) };

declare 'RepeatedInstanceSettingsMetadata',
    as ArrayRef[InstanceSettingsMetadata()];

coerce 'RepeatedInstanceSettingsMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceSettingsMetadata'->new($_) } @$_ ] };

declare 'MapStringInstanceSettingsMetadata',
    as HashRef[InstanceSettingsMetadata()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceSettingsMetadata::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceSettingsMetadata::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceSettingsMetadata::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'InstanceTemplate',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceTemplate'];

coerce 'InstanceTemplate',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceTemplate'->new($_) };

declare 'RepeatedInstanceTemplate',
    as ArrayRef[InstanceTemplate()];

coerce 'RepeatedInstanceTemplate',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceTemplate'->new($_) } @$_ ] };

declare 'MapStringInstanceTemplate',
    as HashRef[InstanceTemplate()];

declare 'InstanceTemplateAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceTemplateAggregatedList'];

coerce 'InstanceTemplateAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceTemplateAggregatedList'->new($_) };

declare 'RepeatedInstanceTemplateAggregatedList',
    as ArrayRef[InstanceTemplateAggregatedList()];

coerce 'RepeatedInstanceTemplateAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceTemplateAggregatedList'->new($_) } @$_ ] };

declare 'MapStringInstanceTemplateAggregatedList',
    as HashRef[InstanceTemplateAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceTemplateAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceTemplateAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceTemplateAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'InstanceTemplateList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceTemplateList'];

coerce 'InstanceTemplateList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceTemplateList'->new($_) };

declare 'RepeatedInstanceTemplateList',
    as ArrayRef[InstanceTemplateList()];

coerce 'RepeatedInstanceTemplateList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceTemplateList'->new($_) } @$_ ] };

declare 'MapStringInstanceTemplateList',
    as HashRef[InstanceTemplateList()];

declare 'InstanceTemplatesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceTemplatesScopedList'];

coerce 'InstanceTemplatesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceTemplatesScopedList'->new($_) };

declare 'RepeatedInstanceTemplatesScopedList',
    as ArrayRef[InstanceTemplatesScopedList()];

coerce 'RepeatedInstanceTemplatesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceTemplatesScopedList'->new($_) } @$_ ] };

declare 'MapStringInstanceTemplatesScopedList',
    as HashRef[InstanceTemplatesScopedList()];

declare 'InstanceWithNamedPorts',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstanceWithNamedPorts'];

coerce 'InstanceWithNamedPorts',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstanceWithNamedPorts'->new($_) };

declare 'RepeatedInstanceWithNamedPorts',
    as ArrayRef[InstanceWithNamedPorts()];

coerce 'RepeatedInstanceWithNamedPorts',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstanceWithNamedPorts'->new($_) } @$_ ] };

declare 'MapStringInstanceWithNamedPorts',
    as HashRef[InstanceWithNamedPorts()];

declare 'Status',
    as (Int | Str);

declare 'InstancesAddResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesAddResourcePoliciesRequest'];

coerce 'InstancesAddResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesAddResourcePoliciesRequest'->new($_) };

declare 'RepeatedInstancesAddResourcePoliciesRequest',
    as ArrayRef[InstancesAddResourcePoliciesRequest()];

coerce 'RepeatedInstancesAddResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesAddResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesAddResourcePoliciesRequest',
    as HashRef[InstancesAddResourcePoliciesRequest()];

declare 'InstancesBulkInsertOperationMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesBulkInsertOperationMetadata'];

coerce 'InstancesBulkInsertOperationMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesBulkInsertOperationMetadata'->new($_) };

declare 'RepeatedInstancesBulkInsertOperationMetadata',
    as ArrayRef[InstancesBulkInsertOperationMetadata()];

coerce 'RepeatedInstancesBulkInsertOperationMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesBulkInsertOperationMetadata'->new($_) } @$_ ] };

declare 'MapStringInstancesBulkInsertOperationMetadata',
    as HashRef[InstancesBulkInsertOperationMetadata()];

declare 'PerLocationStatusEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesBulkInsertOperationMetadata::PerLocationStatusEntry'];

coerce 'PerLocationStatusEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesBulkInsertOperationMetadata::PerLocationStatusEntry'->new($_) };

declare 'RepeatedPerLocationStatusEntry',
    as ArrayRef[PerLocationStatusEntry()];

coerce 'RepeatedPerLocationStatusEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesBulkInsertOperationMetadata::PerLocationStatusEntry'->new($_) } @$_ ] };

declare 'MapStringPerLocationStatusEntry',
    as HashRef[PerLocationStatusEntry()];

declare 'InstancesGetEffectiveFirewallsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesGetEffectiveFirewallsResponse'];

coerce 'InstancesGetEffectiveFirewallsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesGetEffectiveFirewallsResponse'->new($_) };

declare 'RepeatedInstancesGetEffectiveFirewallsResponse',
    as ArrayRef[InstancesGetEffectiveFirewallsResponse()];

coerce 'RepeatedInstancesGetEffectiveFirewallsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesGetEffectiveFirewallsResponse'->new($_) } @$_ ] };

declare 'MapStringInstancesGetEffectiveFirewallsResponse',
    as HashRef[InstancesGetEffectiveFirewallsResponse()];

declare 'InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy'];

coerce 'InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy'->new($_) };

declare 'RepeatedInstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as ArrayRef[InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy()];

coerce 'RepeatedInstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy'->new($_) } @$_ ] };

declare 'MapStringInstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as HashRef[InstancesGetEffectiveFirewallsResponseEffectiveFirewallPolicy()];

declare 'Type',
    as (Int | Str);

declare 'InstancesRemoveResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesRemoveResourcePoliciesRequest'];

coerce 'InstancesRemoveResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesRemoveResourcePoliciesRequest'->new($_) };

declare 'RepeatedInstancesRemoveResourcePoliciesRequest',
    as ArrayRef[InstancesRemoveResourcePoliciesRequest()];

coerce 'RepeatedInstancesRemoveResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesRemoveResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesRemoveResourcePoliciesRequest',
    as HashRef[InstancesRemoveResourcePoliciesRequest()];

declare 'InstancesReportHostAsFaultyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesReportHostAsFaultyRequest'];

coerce 'InstancesReportHostAsFaultyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesReportHostAsFaultyRequest'->new($_) };

declare 'RepeatedInstancesReportHostAsFaultyRequest',
    as ArrayRef[InstancesReportHostAsFaultyRequest()];

coerce 'RepeatedInstancesReportHostAsFaultyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesReportHostAsFaultyRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesReportHostAsFaultyRequest',
    as HashRef[InstancesReportHostAsFaultyRequest()];

declare 'DisruptionSchedule',
    as (Int | Str);

declare 'InstancesReportHostAsFaultyRequestFaultReason',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesReportHostAsFaultyRequestFaultReason'];

coerce 'InstancesReportHostAsFaultyRequestFaultReason',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesReportHostAsFaultyRequestFaultReason'->new($_) };

declare 'RepeatedInstancesReportHostAsFaultyRequestFaultReason',
    as ArrayRef[InstancesReportHostAsFaultyRequestFaultReason()];

coerce 'RepeatedInstancesReportHostAsFaultyRequestFaultReason',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesReportHostAsFaultyRequestFaultReason'->new($_) } @$_ ] };

declare 'MapStringInstancesReportHostAsFaultyRequestFaultReason',
    as HashRef[InstancesReportHostAsFaultyRequestFaultReason()];

declare 'Behavior',
    as (Int | Str);

declare 'InstancesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesScopedList'];

coerce 'InstancesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesScopedList'->new($_) };

declare 'RepeatedInstancesScopedList',
    as ArrayRef[InstancesScopedList()];

coerce 'RepeatedInstancesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesScopedList'->new($_) } @$_ ] };

declare 'MapStringInstancesScopedList',
    as HashRef[InstancesScopedList()];

declare 'InstancesSetLabelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetLabelsRequest'];

coerce 'InstancesSetLabelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetLabelsRequest'->new($_) };

declare 'RepeatedInstancesSetLabelsRequest',
    as ArrayRef[InstancesSetLabelsRequest()];

coerce 'RepeatedInstancesSetLabelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetLabelsRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesSetLabelsRequest',
    as HashRef[InstancesSetLabelsRequest()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetLabelsRequest::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetLabelsRequest::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetLabelsRequest::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'InstancesSetMachineResourcesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetMachineResourcesRequest'];

coerce 'InstancesSetMachineResourcesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetMachineResourcesRequest'->new($_) };

declare 'RepeatedInstancesSetMachineResourcesRequest',
    as ArrayRef[InstancesSetMachineResourcesRequest()];

coerce 'RepeatedInstancesSetMachineResourcesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetMachineResourcesRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesSetMachineResourcesRequest',
    as HashRef[InstancesSetMachineResourcesRequest()];

declare 'InstancesSetMachineTypeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetMachineTypeRequest'];

coerce 'InstancesSetMachineTypeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetMachineTypeRequest'->new($_) };

declare 'RepeatedInstancesSetMachineTypeRequest',
    as ArrayRef[InstancesSetMachineTypeRequest()];

coerce 'RepeatedInstancesSetMachineTypeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetMachineTypeRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesSetMachineTypeRequest',
    as HashRef[InstancesSetMachineTypeRequest()];

declare 'InstancesSetMinCpuPlatformRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetMinCpuPlatformRequest'];

coerce 'InstancesSetMinCpuPlatformRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetMinCpuPlatformRequest'->new($_) };

declare 'RepeatedInstancesSetMinCpuPlatformRequest',
    as ArrayRef[InstancesSetMinCpuPlatformRequest()];

coerce 'RepeatedInstancesSetMinCpuPlatformRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetMinCpuPlatformRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesSetMinCpuPlatformRequest',
    as HashRef[InstancesSetMinCpuPlatformRequest()];

declare 'InstancesSetNameRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetNameRequest'];

coerce 'InstancesSetNameRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetNameRequest'->new($_) };

declare 'RepeatedInstancesSetNameRequest',
    as ArrayRef[InstancesSetNameRequest()];

coerce 'RepeatedInstancesSetNameRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetNameRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesSetNameRequest',
    as HashRef[InstancesSetNameRequest()];

declare 'InstancesSetSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetSecurityPolicyRequest'];

coerce 'InstancesSetSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetSecurityPolicyRequest'->new($_) };

declare 'RepeatedInstancesSetSecurityPolicyRequest',
    as ArrayRef[InstancesSetSecurityPolicyRequest()];

coerce 'RepeatedInstancesSetSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesSetSecurityPolicyRequest',
    as HashRef[InstancesSetSecurityPolicyRequest()];

declare 'InstancesSetServiceAccountRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesSetServiceAccountRequest'];

coerce 'InstancesSetServiceAccountRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesSetServiceAccountRequest'->new($_) };

declare 'RepeatedInstancesSetServiceAccountRequest',
    as ArrayRef[InstancesSetServiceAccountRequest()];

coerce 'RepeatedInstancesSetServiceAccountRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesSetServiceAccountRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesSetServiceAccountRequest',
    as HashRef[InstancesSetServiceAccountRequest()];

declare 'InstancesStartWithEncryptionKeyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstancesStartWithEncryptionKeyRequest'];

coerce 'InstancesStartWithEncryptionKeyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstancesStartWithEncryptionKeyRequest'->new($_) };

declare 'RepeatedInstancesStartWithEncryptionKeyRequest',
    as ArrayRef[InstancesStartWithEncryptionKeyRequest()];

coerce 'RepeatedInstancesStartWithEncryptionKeyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstancesStartWithEncryptionKeyRequest'->new($_) } @$_ ] };

declare 'MapStringInstancesStartWithEncryptionKeyRequest',
    as HashRef[InstancesStartWithEncryptionKeyRequest()];

declare 'InstantSnapshot',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshot'];

coerce 'InstantSnapshot',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshot'->new($_) };

declare 'RepeatedInstantSnapshot',
    as ArrayRef[InstantSnapshot()];

coerce 'RepeatedInstantSnapshot',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshot'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshot',
    as HashRef[InstantSnapshot()];

declare 'Architecture',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshot::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshot::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshot::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'InstantSnapshotAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotAggregatedList'];

coerce 'InstantSnapshotAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotAggregatedList'->new($_) };

declare 'RepeatedInstantSnapshotAggregatedList',
    as ArrayRef[InstantSnapshotAggregatedList()];

coerce 'RepeatedInstantSnapshotAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotAggregatedList'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotAggregatedList',
    as HashRef[InstantSnapshotAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'InstantSnapshotGroup',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotGroup'];

coerce 'InstantSnapshotGroup',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroup'->new($_) };

declare 'RepeatedInstantSnapshotGroup',
    as ArrayRef[InstantSnapshotGroup()];

coerce 'RepeatedInstantSnapshotGroup',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroup'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotGroup',
    as HashRef[InstantSnapshotGroup()];

declare 'Status',
    as (Int | Str);

declare 'InstantSnapshotGroupParameters',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupParameters'];

coerce 'InstantSnapshotGroupParameters',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupParameters'->new($_) };

declare 'RepeatedInstantSnapshotGroupParameters',
    as ArrayRef[InstantSnapshotGroupParameters()];

coerce 'RepeatedInstantSnapshotGroupParameters',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupParameters'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotGroupParameters',
    as HashRef[InstantSnapshotGroupParameters()];

declare 'InstantSnapshotGroupResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupResourceStatus'];

coerce 'InstantSnapshotGroupResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupResourceStatus'->new($_) };

declare 'RepeatedInstantSnapshotGroupResourceStatus',
    as ArrayRef[InstantSnapshotGroupResourceStatus()];

coerce 'RepeatedInstantSnapshotGroupResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupResourceStatus'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotGroupResourceStatus',
    as HashRef[InstantSnapshotGroupResourceStatus()];

declare 'InstantSnapshotGroupSourceInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupSourceInfo'];

coerce 'InstantSnapshotGroupSourceInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupSourceInfo'->new($_) };

declare 'RepeatedInstantSnapshotGroupSourceInfo',
    as ArrayRef[InstantSnapshotGroupSourceInfo()];

coerce 'RepeatedInstantSnapshotGroupSourceInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotGroupSourceInfo'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotGroupSourceInfo',
    as HashRef[InstantSnapshotGroupSourceInfo()];

declare 'InstantSnapshotList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotList'];

coerce 'InstantSnapshotList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotList'->new($_) };

declare 'RepeatedInstantSnapshotList',
    as ArrayRef[InstantSnapshotList()];

coerce 'RepeatedInstantSnapshotList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotList'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotList',
    as HashRef[InstantSnapshotList()];

declare 'InstantSnapshotParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotParams'];

coerce 'InstantSnapshotParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotParams'->new($_) };

declare 'RepeatedInstantSnapshotParams',
    as ArrayRef[InstantSnapshotParams()];

coerce 'RepeatedInstantSnapshotParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotParams'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotParams',
    as HashRef[InstantSnapshotParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'InstantSnapshotResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotResourceStatus'];

coerce 'InstantSnapshotResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotResourceStatus'->new($_) };

declare 'RepeatedInstantSnapshotResourceStatus',
    as ArrayRef[InstantSnapshotResourceStatus()];

coerce 'RepeatedInstantSnapshotResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotResourceStatus'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotResourceStatus',
    as HashRef[InstantSnapshotResourceStatus()];

declare 'InstantSnapshotsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InstantSnapshotsScopedList'];

coerce 'InstantSnapshotsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotsScopedList'->new($_) };

declare 'RepeatedInstantSnapshotsScopedList',
    as ArrayRef[InstantSnapshotsScopedList()];

coerce 'RepeatedInstantSnapshotsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InstantSnapshotsScopedList'->new($_) } @$_ ] };

declare 'MapStringInstantSnapshotsScopedList',
    as HashRef[InstantSnapshotsScopedList()];

declare 'Int64RangeMatch',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Int64RangeMatch'];

coerce 'Int64RangeMatch',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Int64RangeMatch'->new($_) };

declare 'RepeatedInt64RangeMatch',
    as ArrayRef[Int64RangeMatch()];

coerce 'RepeatedInt64RangeMatch',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Int64RangeMatch'->new($_) } @$_ ] };

declare 'MapStringInt64RangeMatch',
    as HashRef[Int64RangeMatch()];

declare 'Interconnect',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Interconnect'];

coerce 'Interconnect',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Interconnect'->new($_) };

declare 'RepeatedInterconnect',
    as ArrayRef[Interconnect()];

coerce 'RepeatedInterconnect',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Interconnect'->new($_) } @$_ ] };

declare 'MapStringInterconnect',
    as HashRef[Interconnect()];

declare 'AvailableFeatures',
    as (Int | Str);

declare 'InterconnectType',
    as (Int | Str);

declare 'LinkType',
    as (Int | Str);

declare 'OperationalStatus',
    as (Int | Str);

declare 'RequestedFeatures',
    as (Int | Str);

declare 'State',
    as (Int | Str);

declare 'Subzone',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Interconnect::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Interconnect::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Interconnect::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'InterconnectApplicationAwareInterconnect',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnect'];

coerce 'InterconnectApplicationAwareInterconnect',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnect'->new($_) };

declare 'RepeatedInterconnectApplicationAwareInterconnect',
    as ArrayRef[InterconnectApplicationAwareInterconnect()];

coerce 'RepeatedInterconnectApplicationAwareInterconnect',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnect'->new($_) } @$_ ] };

declare 'MapStringInterconnectApplicationAwareInterconnect',
    as HashRef[InterconnectApplicationAwareInterconnect()];

declare 'InterconnectApplicationAwareInterconnectBandwidthPercentage',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectBandwidthPercentage'];

coerce 'InterconnectApplicationAwareInterconnectBandwidthPercentage',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectBandwidthPercentage'->new($_) };

declare 'RepeatedInterconnectApplicationAwareInterconnectBandwidthPercentage',
    as ArrayRef[InterconnectApplicationAwareInterconnectBandwidthPercentage()];

coerce 'RepeatedInterconnectApplicationAwareInterconnectBandwidthPercentage',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectBandwidthPercentage'->new($_) } @$_ ] };

declare 'MapStringInterconnectApplicationAwareInterconnectBandwidthPercentage',
    as HashRef[InterconnectApplicationAwareInterconnectBandwidthPercentage()];

declare 'TrafficClass',
    as (Int | Str);

declare 'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy'];

coerce 'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy'->new($_) };

declare 'RepeatedInterconnectApplicationAwareInterconnectBandwidthPercentagePolicy',
    as ArrayRef[InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy()];

coerce 'RepeatedInterconnectApplicationAwareInterconnectBandwidthPercentagePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy'->new($_) } @$_ ] };

declare 'MapStringInterconnectApplicationAwareInterconnectBandwidthPercentagePolicy',
    as HashRef[InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy()];

declare 'InterconnectApplicationAwareInterconnectStrictPriorityPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectStrictPriorityPolicy'];

coerce 'InterconnectApplicationAwareInterconnectStrictPriorityPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectStrictPriorityPolicy'->new($_) };

declare 'RepeatedInterconnectApplicationAwareInterconnectStrictPriorityPolicy',
    as ArrayRef[InterconnectApplicationAwareInterconnectStrictPriorityPolicy()];

coerce 'RepeatedInterconnectApplicationAwareInterconnectStrictPriorityPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectApplicationAwareInterconnectStrictPriorityPolicy'->new($_) } @$_ ] };

declare 'MapStringInterconnectApplicationAwareInterconnectStrictPriorityPolicy',
    as HashRef[InterconnectApplicationAwareInterconnectStrictPriorityPolicy()];

declare 'InterconnectAttachment',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachment'];

coerce 'InterconnectAttachment',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachment'->new($_) };

declare 'RepeatedInterconnectAttachment',
    as ArrayRef[InterconnectAttachment()];

coerce 'RepeatedInterconnectAttachment',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachment'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachment',
    as HashRef[InterconnectAttachment()];

declare 'Bandwidth',
    as (Int | Str);

declare 'EdgeAvailabilityDomain',
    as (Int | Str);

declare 'Encryption',
    as (Int | Str);

declare 'OperationalStatus',
    as (Int | Str);

declare 'StackType',
    as (Int | Str);

declare 'State',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachment::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachment::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachment::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'InterconnectAttachmentAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentAggregatedList'];

coerce 'InterconnectAttachmentAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentAggregatedList'->new($_) };

declare 'RepeatedInterconnectAttachmentAggregatedList',
    as ArrayRef[InterconnectAttachmentAggregatedList()];

coerce 'RepeatedInterconnectAttachmentAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentAggregatedList'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentAggregatedList',
    as HashRef[InterconnectAttachmentAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'InterconnectAttachmentConfigurationConstraints',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentConfigurationConstraints'];

coerce 'InterconnectAttachmentConfigurationConstraints',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentConfigurationConstraints'->new($_) };

declare 'RepeatedInterconnectAttachmentConfigurationConstraints',
    as ArrayRef[InterconnectAttachmentConfigurationConstraints()];

coerce 'RepeatedInterconnectAttachmentConfigurationConstraints',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentConfigurationConstraints'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentConfigurationConstraints',
    as HashRef[InterconnectAttachmentConfigurationConstraints()];

declare 'BgpMd5',
    as (Int | Str);

declare 'InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange'];

coerce 'InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange'->new($_) };

declare 'RepeatedInterconnectAttachmentConfigurationConstraintsBgpPeerASNRange',
    as ArrayRef[InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange()];

coerce 'RepeatedInterconnectAttachmentConfigurationConstraintsBgpPeerASNRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentConfigurationConstraintsBgpPeerASNRange',
    as HashRef[InterconnectAttachmentConfigurationConstraintsBgpPeerASNRange()];

declare 'InterconnectAttachmentGroup',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroup'];

coerce 'InterconnectAttachmentGroup',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroup'->new($_) };

declare 'RepeatedInterconnectAttachmentGroup',
    as ArrayRef[InterconnectAttachmentGroup()];

coerce 'RepeatedInterconnectAttachmentGroup',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroup'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroup',
    as HashRef[InterconnectAttachmentGroup()];

declare 'AttachmentsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroup::AttachmentsEntry'];

coerce 'AttachmentsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroup::AttachmentsEntry'->new($_) };

declare 'RepeatedAttachmentsEntry',
    as ArrayRef[AttachmentsEntry()];

coerce 'RepeatedAttachmentsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroup::AttachmentsEntry'->new($_) } @$_ ] };

declare 'MapStringAttachmentsEntry',
    as HashRef[AttachmentsEntry()];

declare 'InterconnectAttachmentGroupAttachment',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupAttachment'];

coerce 'InterconnectAttachmentGroupAttachment',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupAttachment'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupAttachment',
    as ArrayRef[InterconnectAttachmentGroupAttachment()];

coerce 'RepeatedInterconnectAttachmentGroupAttachment',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupAttachment'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupAttachment',
    as HashRef[InterconnectAttachmentGroupAttachment()];

declare 'InterconnectAttachmentGroupConfigured',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfigured'];

coerce 'InterconnectAttachmentGroupConfigured',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfigured'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupConfigured',
    as ArrayRef[InterconnectAttachmentGroupConfigured()];

coerce 'RepeatedInterconnectAttachmentGroupConfigured',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfigured'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupConfigured',
    as HashRef[InterconnectAttachmentGroupConfigured()];

declare 'InterconnectAttachmentGroupConfiguredAvailabilitySLA',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfiguredAvailabilitySLA'];

coerce 'InterconnectAttachmentGroupConfiguredAvailabilitySLA',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfiguredAvailabilitySLA'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupConfiguredAvailabilitySLA',
    as ArrayRef[InterconnectAttachmentGroupConfiguredAvailabilitySLA()];

coerce 'RepeatedInterconnectAttachmentGroupConfiguredAvailabilitySLA',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfiguredAvailabilitySLA'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupConfiguredAvailabilitySLA',
    as HashRef[InterconnectAttachmentGroupConfiguredAvailabilitySLA()];

declare 'EffectiveSla',
    as (Int | Str);

declare 'InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers'];

coerce 'InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers',
    as ArrayRef[InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers()];

coerce 'RepeatedInterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers',
    as HashRef[InterconnectAttachmentGroupConfiguredAvailabilitySLAIntendedSlaBlockers()];

declare 'BlockerType',
    as (Int | Str);

declare 'InterconnectAttachmentGroupIntent',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupIntent'];

coerce 'InterconnectAttachmentGroupIntent',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupIntent'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupIntent',
    as ArrayRef[InterconnectAttachmentGroupIntent()];

coerce 'RepeatedInterconnectAttachmentGroupIntent',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupIntent'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupIntent',
    as HashRef[InterconnectAttachmentGroupIntent()];

declare 'AvailabilitySla',
    as (Int | Str);

declare 'InterconnectAttachmentGroupLogicalStructure',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructure'];

coerce 'InterconnectAttachmentGroupLogicalStructure',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructure'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupLogicalStructure',
    as ArrayRef[InterconnectAttachmentGroupLogicalStructure()];

coerce 'RepeatedInterconnectAttachmentGroupLogicalStructure',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructure'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupLogicalStructure',
    as HashRef[InterconnectAttachmentGroupLogicalStructure()];

declare 'InterconnectAttachmentGroupLogicalStructureRegion',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegion'];

coerce 'InterconnectAttachmentGroupLogicalStructureRegion',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegion'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupLogicalStructureRegion',
    as ArrayRef[InterconnectAttachmentGroupLogicalStructureRegion()];

coerce 'RepeatedInterconnectAttachmentGroupLogicalStructureRegion',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegion'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupLogicalStructureRegion',
    as HashRef[InterconnectAttachmentGroupLogicalStructureRegion()];

declare 'InterconnectAttachmentGroupLogicalStructureRegionMetro',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetro'];

coerce 'InterconnectAttachmentGroupLogicalStructureRegionMetro',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetro'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupLogicalStructureRegionMetro',
    as ArrayRef[InterconnectAttachmentGroupLogicalStructureRegionMetro()];

coerce 'RepeatedInterconnectAttachmentGroupLogicalStructureRegionMetro',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetro'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupLogicalStructureRegionMetro',
    as HashRef[InterconnectAttachmentGroupLogicalStructureRegionMetro()];

declare 'InterconnectAttachmentGroupLogicalStructureRegionMetroFacility',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetroFacility'];

coerce 'InterconnectAttachmentGroupLogicalStructureRegionMetroFacility',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetroFacility'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupLogicalStructureRegionMetroFacility',
    as ArrayRef[InterconnectAttachmentGroupLogicalStructureRegionMetroFacility()];

coerce 'RepeatedInterconnectAttachmentGroupLogicalStructureRegionMetroFacility',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetroFacility'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupLogicalStructureRegionMetroFacility',
    as HashRef[InterconnectAttachmentGroupLogicalStructureRegionMetroFacility()];

declare 'InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone'];

coerce 'InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone',
    as ArrayRef[InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone()];

coerce 'RepeatedInterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone',
    as HashRef[InterconnectAttachmentGroupLogicalStructureRegionMetroFacilityZone()];

declare 'InterconnectAttachmentGroupsGetOperationalStatusResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsGetOperationalStatusResponse'];

coerce 'InterconnectAttachmentGroupsGetOperationalStatusResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsGetOperationalStatusResponse'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupsGetOperationalStatusResponse',
    as ArrayRef[InterconnectAttachmentGroupsGetOperationalStatusResponse()];

coerce 'RepeatedInterconnectAttachmentGroupsGetOperationalStatusResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsGetOperationalStatusResponse'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupsGetOperationalStatusResponse',
    as HashRef[InterconnectAttachmentGroupsGetOperationalStatusResponse()];

declare 'InterconnectAttachmentGroupsListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsListResponse'];

coerce 'InterconnectAttachmentGroupsListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsListResponse'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupsListResponse',
    as ArrayRef[InterconnectAttachmentGroupsListResponse()];

coerce 'RepeatedInterconnectAttachmentGroupsListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsListResponse'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupsListResponse',
    as HashRef[InterconnectAttachmentGroupsListResponse()];

declare 'InterconnectAttachmentGroupsOperationalStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsOperationalStatus'];

coerce 'InterconnectAttachmentGroupsOperationalStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsOperationalStatus'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupsOperationalStatus',
    as ArrayRef[InterconnectAttachmentGroupsOperationalStatus()];

coerce 'RepeatedInterconnectAttachmentGroupsOperationalStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsOperationalStatus'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupsOperationalStatus',
    as HashRef[InterconnectAttachmentGroupsOperationalStatus()];

declare 'GroupStatus',
    as (Int | Str);

declare 'InterconnectAttachmentGroupsOperationalStatusAttachmentStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsOperationalStatusAttachmentStatus'];

coerce 'InterconnectAttachmentGroupsOperationalStatusAttachmentStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsOperationalStatusAttachmentStatus'->new($_) };

declare 'RepeatedInterconnectAttachmentGroupsOperationalStatusAttachmentStatus',
    as ArrayRef[InterconnectAttachmentGroupsOperationalStatusAttachmentStatus()];

coerce 'RepeatedInterconnectAttachmentGroupsOperationalStatusAttachmentStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentGroupsOperationalStatusAttachmentStatus'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentGroupsOperationalStatusAttachmentStatus',
    as HashRef[InterconnectAttachmentGroupsOperationalStatusAttachmentStatus()];

declare 'IsActive',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'InterconnectAttachmentL2Forwarding',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2Forwarding'];

coerce 'InterconnectAttachmentL2Forwarding',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2Forwarding'->new($_) };

declare 'RepeatedInterconnectAttachmentL2Forwarding',
    as ArrayRef[InterconnectAttachmentL2Forwarding()];

coerce 'RepeatedInterconnectAttachmentL2Forwarding',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2Forwarding'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentL2Forwarding',
    as HashRef[InterconnectAttachmentL2Forwarding()];

declare 'ApplianceMappingsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2Forwarding::ApplianceMappingsEntry'];

coerce 'ApplianceMappingsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2Forwarding::ApplianceMappingsEntry'->new($_) };

declare 'RepeatedApplianceMappingsEntry',
    as ArrayRef[ApplianceMappingsEntry()];

coerce 'RepeatedApplianceMappingsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2Forwarding::ApplianceMappingsEntry'->new($_) } @$_ ] };

declare 'MapStringApplianceMappingsEntry',
    as HashRef[ApplianceMappingsEntry()];

declare 'InterconnectAttachmentL2ForwardingApplianceMapping',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingApplianceMapping'];

coerce 'InterconnectAttachmentL2ForwardingApplianceMapping',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingApplianceMapping'->new($_) };

declare 'RepeatedInterconnectAttachmentL2ForwardingApplianceMapping',
    as ArrayRef[InterconnectAttachmentL2ForwardingApplianceMapping()];

coerce 'RepeatedInterconnectAttachmentL2ForwardingApplianceMapping',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingApplianceMapping'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentL2ForwardingApplianceMapping',
    as HashRef[InterconnectAttachmentL2ForwardingApplianceMapping()];

declare 'InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping'];

coerce 'InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping'->new($_) };

declare 'RepeatedInterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping',
    as ArrayRef[InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping()];

coerce 'RepeatedInterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping',
    as HashRef[InterconnectAttachmentL2ForwardingApplianceMappingInnerVlanToApplianceMapping()];

declare 'InterconnectAttachmentL2ForwardingGeneveHeader',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingGeneveHeader'];

coerce 'InterconnectAttachmentL2ForwardingGeneveHeader',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingGeneveHeader'->new($_) };

declare 'RepeatedInterconnectAttachmentL2ForwardingGeneveHeader',
    as ArrayRef[InterconnectAttachmentL2ForwardingGeneveHeader()];

coerce 'RepeatedInterconnectAttachmentL2ForwardingGeneveHeader',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentL2ForwardingGeneveHeader'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentL2ForwardingGeneveHeader',
    as HashRef[InterconnectAttachmentL2ForwardingGeneveHeader()];

declare 'InterconnectAttachmentList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentList'];

coerce 'InterconnectAttachmentList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentList'->new($_) };

declare 'RepeatedInterconnectAttachmentList',
    as ArrayRef[InterconnectAttachmentList()];

coerce 'RepeatedInterconnectAttachmentList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentList'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentList',
    as HashRef[InterconnectAttachmentList()];

declare 'InterconnectAttachmentParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentParams'];

coerce 'InterconnectAttachmentParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentParams'->new($_) };

declare 'RepeatedInterconnectAttachmentParams',
    as ArrayRef[InterconnectAttachmentParams()];

coerce 'RepeatedInterconnectAttachmentParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentParams'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentParams',
    as HashRef[InterconnectAttachmentParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'InterconnectAttachmentPartnerMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentPartnerMetadata'];

coerce 'InterconnectAttachmentPartnerMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentPartnerMetadata'->new($_) };

declare 'RepeatedInterconnectAttachmentPartnerMetadata',
    as ArrayRef[InterconnectAttachmentPartnerMetadata()];

coerce 'RepeatedInterconnectAttachmentPartnerMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentPartnerMetadata'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentPartnerMetadata',
    as HashRef[InterconnectAttachmentPartnerMetadata()];

declare 'InterconnectAttachmentPrivateInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentPrivateInfo'];

coerce 'InterconnectAttachmentPrivateInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentPrivateInfo'->new($_) };

declare 'RepeatedInterconnectAttachmentPrivateInfo',
    as ArrayRef[InterconnectAttachmentPrivateInfo()];

coerce 'RepeatedInterconnectAttachmentPrivateInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentPrivateInfo'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentPrivateInfo',
    as HashRef[InterconnectAttachmentPrivateInfo()];

declare 'InterconnectAttachmentsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectAttachmentsScopedList'];

coerce 'InterconnectAttachmentsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentsScopedList'->new($_) };

declare 'RepeatedInterconnectAttachmentsScopedList',
    as ArrayRef[InterconnectAttachmentsScopedList()];

coerce 'RepeatedInterconnectAttachmentsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectAttachmentsScopedList'->new($_) } @$_ ] };

declare 'MapStringInterconnectAttachmentsScopedList',
    as HashRef[InterconnectAttachmentsScopedList()];

declare 'InterconnectCircuitInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectCircuitInfo'];

coerce 'InterconnectCircuitInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectCircuitInfo'->new($_) };

declare 'RepeatedInterconnectCircuitInfo',
    as ArrayRef[InterconnectCircuitInfo()];

coerce 'RepeatedInterconnectCircuitInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectCircuitInfo'->new($_) } @$_ ] };

declare 'MapStringInterconnectCircuitInfo',
    as HashRef[InterconnectCircuitInfo()];

declare 'InterconnectDiagnostics',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectDiagnostics'];

coerce 'InterconnectDiagnostics',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnostics'->new($_) };

declare 'RepeatedInterconnectDiagnostics',
    as ArrayRef[InterconnectDiagnostics()];

coerce 'RepeatedInterconnectDiagnostics',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnostics'->new($_) } @$_ ] };

declare 'MapStringInterconnectDiagnostics',
    as HashRef[InterconnectDiagnostics()];

declare 'BundleAggregationType',
    as (Int | Str);

declare 'BundleOperationalStatus',
    as (Int | Str);

declare 'InterconnectDiagnosticsARPEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsARPEntry'];

coerce 'InterconnectDiagnosticsARPEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsARPEntry'->new($_) };

declare 'RepeatedInterconnectDiagnosticsARPEntry',
    as ArrayRef[InterconnectDiagnosticsARPEntry()];

coerce 'RepeatedInterconnectDiagnosticsARPEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsARPEntry'->new($_) } @$_ ] };

declare 'MapStringInterconnectDiagnosticsARPEntry',
    as HashRef[InterconnectDiagnosticsARPEntry()];

declare 'InterconnectDiagnosticsLinkLACPStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkLACPStatus'];

coerce 'InterconnectDiagnosticsLinkLACPStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkLACPStatus'->new($_) };

declare 'RepeatedInterconnectDiagnosticsLinkLACPStatus',
    as ArrayRef[InterconnectDiagnosticsLinkLACPStatus()];

coerce 'RepeatedInterconnectDiagnosticsLinkLACPStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkLACPStatus'->new($_) } @$_ ] };

declare 'MapStringInterconnectDiagnosticsLinkLACPStatus',
    as HashRef[InterconnectDiagnosticsLinkLACPStatus()];

declare 'State',
    as (Int | Str);

declare 'InterconnectDiagnosticsLinkOpticalPower',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkOpticalPower'];

coerce 'InterconnectDiagnosticsLinkOpticalPower',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkOpticalPower'->new($_) };

declare 'RepeatedInterconnectDiagnosticsLinkOpticalPower',
    as ArrayRef[InterconnectDiagnosticsLinkOpticalPower()];

coerce 'RepeatedInterconnectDiagnosticsLinkOpticalPower',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkOpticalPower'->new($_) } @$_ ] };

declare 'MapStringInterconnectDiagnosticsLinkOpticalPower',
    as HashRef[InterconnectDiagnosticsLinkOpticalPower()];

declare 'State',
    as (Int | Str);

declare 'InterconnectDiagnosticsLinkStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkStatus'];

coerce 'InterconnectDiagnosticsLinkStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkStatus'->new($_) };

declare 'RepeatedInterconnectDiagnosticsLinkStatus',
    as ArrayRef[InterconnectDiagnosticsLinkStatus()];

coerce 'RepeatedInterconnectDiagnosticsLinkStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsLinkStatus'->new($_) } @$_ ] };

declare 'MapStringInterconnectDiagnosticsLinkStatus',
    as HashRef[InterconnectDiagnosticsLinkStatus()];

declare 'OperationalStatus',
    as (Int | Str);

declare 'InterconnectDiagnosticsMacsecStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsMacsecStatus'];

coerce 'InterconnectDiagnosticsMacsecStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsMacsecStatus'->new($_) };

declare 'RepeatedInterconnectDiagnosticsMacsecStatus',
    as ArrayRef[InterconnectDiagnosticsMacsecStatus()];

coerce 'RepeatedInterconnectDiagnosticsMacsecStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectDiagnosticsMacsecStatus'->new($_) } @$_ ] };

declare 'MapStringInterconnectDiagnosticsMacsecStatus',
    as HashRef[InterconnectDiagnosticsMacsecStatus()];

declare 'InterconnectGroup',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroup'];

coerce 'InterconnectGroup',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroup'->new($_) };

declare 'RepeatedInterconnectGroup',
    as ArrayRef[InterconnectGroup()];

coerce 'RepeatedInterconnectGroup',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroup'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroup',
    as HashRef[InterconnectGroup()];

declare 'InterconnectsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroup::InterconnectsEntry'];

coerce 'InterconnectsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroup::InterconnectsEntry'->new($_) };

declare 'RepeatedInterconnectsEntry',
    as ArrayRef[InterconnectsEntry()];

coerce 'RepeatedInterconnectsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroup::InterconnectsEntry'->new($_) } @$_ ] };

declare 'MapStringInterconnectsEntry',
    as HashRef[InterconnectsEntry()];

declare 'InterconnectGroupConfigured',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupConfigured'];

coerce 'InterconnectGroupConfigured',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupConfigured'->new($_) };

declare 'RepeatedInterconnectGroupConfigured',
    as ArrayRef[InterconnectGroupConfigured()];

coerce 'RepeatedInterconnectGroupConfigured',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupConfigured'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupConfigured',
    as HashRef[InterconnectGroupConfigured()];

declare 'InterconnectGroupConfiguredTopologyCapability',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupConfiguredTopologyCapability'];

coerce 'InterconnectGroupConfiguredTopologyCapability',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupConfiguredTopologyCapability'->new($_) };

declare 'RepeatedInterconnectGroupConfiguredTopologyCapability',
    as ArrayRef[InterconnectGroupConfiguredTopologyCapability()];

coerce 'RepeatedInterconnectGroupConfiguredTopologyCapability',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupConfiguredTopologyCapability'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupConfiguredTopologyCapability',
    as HashRef[InterconnectGroupConfiguredTopologyCapability()];

declare 'SupportedSla',
    as (Int | Str);

declare 'InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers'];

coerce 'InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers'->new($_) };

declare 'RepeatedInterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers',
    as ArrayRef[InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers()];

coerce 'RepeatedInterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers',
    as HashRef[InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockers()];

declare 'BlockerType',
    as (Int | Str);

declare 'InterconnectGroupIntent',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupIntent'];

coerce 'InterconnectGroupIntent',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupIntent'->new($_) };

declare 'RepeatedInterconnectGroupIntent',
    as ArrayRef[InterconnectGroupIntent()];

coerce 'RepeatedInterconnectGroupIntent',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupIntent'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupIntent',
    as HashRef[InterconnectGroupIntent()];

declare 'TopologyCapability',
    as (Int | Str);

declare 'InterconnectGroupInterconnect',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupInterconnect'];

coerce 'InterconnectGroupInterconnect',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupInterconnect'->new($_) };

declare 'RepeatedInterconnectGroupInterconnect',
    as ArrayRef[InterconnectGroupInterconnect()];

coerce 'RepeatedInterconnectGroupInterconnect',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupInterconnect'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupInterconnect',
    as HashRef[InterconnectGroupInterconnect()];

declare 'InterconnectGroupPhysicalStructure',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructure'];

coerce 'InterconnectGroupPhysicalStructure',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructure'->new($_) };

declare 'RepeatedInterconnectGroupPhysicalStructure',
    as ArrayRef[InterconnectGroupPhysicalStructure()];

coerce 'RepeatedInterconnectGroupPhysicalStructure',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructure'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupPhysicalStructure',
    as HashRef[InterconnectGroupPhysicalStructure()];

declare 'InterconnectGroupPhysicalStructureMetros',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetros'];

coerce 'InterconnectGroupPhysicalStructureMetros',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetros'->new($_) };

declare 'RepeatedInterconnectGroupPhysicalStructureMetros',
    as ArrayRef[InterconnectGroupPhysicalStructureMetros()];

coerce 'RepeatedInterconnectGroupPhysicalStructureMetros',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetros'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupPhysicalStructureMetros',
    as HashRef[InterconnectGroupPhysicalStructureMetros()];

declare 'InterconnectGroupPhysicalStructureMetrosFacilities',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetrosFacilities'];

coerce 'InterconnectGroupPhysicalStructureMetrosFacilities',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetrosFacilities'->new($_) };

declare 'RepeatedInterconnectGroupPhysicalStructureMetrosFacilities',
    as ArrayRef[InterconnectGroupPhysicalStructureMetrosFacilities()];

coerce 'RepeatedInterconnectGroupPhysicalStructureMetrosFacilities',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetrosFacilities'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupPhysicalStructureMetrosFacilities',
    as HashRef[InterconnectGroupPhysicalStructureMetrosFacilities()];

declare 'InterconnectGroupPhysicalStructureMetrosFacilitiesZones',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetrosFacilitiesZones'];

coerce 'InterconnectGroupPhysicalStructureMetrosFacilitiesZones',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetrosFacilitiesZones'->new($_) };

declare 'RepeatedInterconnectGroupPhysicalStructureMetrosFacilitiesZones',
    as ArrayRef[InterconnectGroupPhysicalStructureMetrosFacilitiesZones()];

coerce 'RepeatedInterconnectGroupPhysicalStructureMetrosFacilitiesZones',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupPhysicalStructureMetrosFacilitiesZones'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupPhysicalStructureMetrosFacilitiesZones',
    as HashRef[InterconnectGroupPhysicalStructureMetrosFacilitiesZones()];

declare 'InterconnectGroupsCreateMembers',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembers'];

coerce 'InterconnectGroupsCreateMembers',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembers'->new($_) };

declare 'RepeatedInterconnectGroupsCreateMembers',
    as ArrayRef[InterconnectGroupsCreateMembers()];

coerce 'RepeatedInterconnectGroupsCreateMembers',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembers'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupsCreateMembers',
    as HashRef[InterconnectGroupsCreateMembers()];

declare 'IntentMismatchBehavior',
    as (Int | Str);

declare 'InterconnectGroupsCreateMembersInterconnectInput',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembersInterconnectInput'];

coerce 'InterconnectGroupsCreateMembersInterconnectInput',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembersInterconnectInput'->new($_) };

declare 'RepeatedInterconnectGroupsCreateMembersInterconnectInput',
    as ArrayRef[InterconnectGroupsCreateMembersInterconnectInput()];

coerce 'RepeatedInterconnectGroupsCreateMembersInterconnectInput',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembersInterconnectInput'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupsCreateMembersInterconnectInput',
    as HashRef[InterconnectGroupsCreateMembersInterconnectInput()];

declare 'InterconnectType',
    as (Int | Str);

declare 'LinkType',
    as (Int | Str);

declare 'RequestedFeatures',
    as (Int | Str);

declare 'InterconnectGroupsCreateMembersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembersRequest'];

coerce 'InterconnectGroupsCreateMembersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembersRequest'->new($_) };

declare 'RepeatedInterconnectGroupsCreateMembersRequest',
    as ArrayRef[InterconnectGroupsCreateMembersRequest()];

coerce 'RepeatedInterconnectGroupsCreateMembersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsCreateMembersRequest'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupsCreateMembersRequest',
    as HashRef[InterconnectGroupsCreateMembersRequest()];

declare 'InterconnectGroupsGetOperationalStatusResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupsGetOperationalStatusResponse'];

coerce 'InterconnectGroupsGetOperationalStatusResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsGetOperationalStatusResponse'->new($_) };

declare 'RepeatedInterconnectGroupsGetOperationalStatusResponse',
    as ArrayRef[InterconnectGroupsGetOperationalStatusResponse()];

coerce 'RepeatedInterconnectGroupsGetOperationalStatusResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsGetOperationalStatusResponse'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupsGetOperationalStatusResponse',
    as HashRef[InterconnectGroupsGetOperationalStatusResponse()];

declare 'InterconnectGroupsListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupsListResponse'];

coerce 'InterconnectGroupsListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsListResponse'->new($_) };

declare 'RepeatedInterconnectGroupsListResponse',
    as ArrayRef[InterconnectGroupsListResponse()];

coerce 'RepeatedInterconnectGroupsListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsListResponse'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupsListResponse',
    as HashRef[InterconnectGroupsListResponse()];

declare 'InterconnectGroupsOperationalStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupsOperationalStatus'];

coerce 'InterconnectGroupsOperationalStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsOperationalStatus'->new($_) };

declare 'RepeatedInterconnectGroupsOperationalStatus',
    as ArrayRef[InterconnectGroupsOperationalStatus()];

coerce 'RepeatedInterconnectGroupsOperationalStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsOperationalStatus'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupsOperationalStatus',
    as HashRef[InterconnectGroupsOperationalStatus()];

declare 'GroupStatus',
    as (Int | Str);

declare 'InterconnectGroupsOperationalStatusInterconnectStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectGroupsOperationalStatusInterconnectStatus'];

coerce 'InterconnectGroupsOperationalStatusInterconnectStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsOperationalStatusInterconnectStatus'->new($_) };

declare 'RepeatedInterconnectGroupsOperationalStatusInterconnectStatus',
    as ArrayRef[InterconnectGroupsOperationalStatusInterconnectStatus()];

coerce 'RepeatedInterconnectGroupsOperationalStatusInterconnectStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectGroupsOperationalStatusInterconnectStatus'->new($_) } @$_ ] };

declare 'MapStringInterconnectGroupsOperationalStatusInterconnectStatus',
    as HashRef[InterconnectGroupsOperationalStatusInterconnectStatus()];

declare 'IsActive',
    as (Int | Str);

declare 'InterconnectList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectList'];

coerce 'InterconnectList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectList'->new($_) };

declare 'RepeatedInterconnectList',
    as ArrayRef[InterconnectList()];

coerce 'RepeatedInterconnectList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectList'->new($_) } @$_ ] };

declare 'MapStringInterconnectList',
    as HashRef[InterconnectList()];

declare 'InterconnectLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectLocation'];

coerce 'InterconnectLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectLocation'->new($_) };

declare 'RepeatedInterconnectLocation',
    as ArrayRef[InterconnectLocation()];

coerce 'RepeatedInterconnectLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectLocation'->new($_) } @$_ ] };

declare 'MapStringInterconnectLocation',
    as HashRef[InterconnectLocation()];

declare 'AvailableFeatures',
    as (Int | Str);

declare 'AvailableLinkTypes',
    as (Int | Str);

declare 'Continent',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'InterconnectLocationCrossSiteInterconnectInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectLocationCrossSiteInterconnectInfo'];

coerce 'InterconnectLocationCrossSiteInterconnectInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectLocationCrossSiteInterconnectInfo'->new($_) };

declare 'RepeatedInterconnectLocationCrossSiteInterconnectInfo',
    as ArrayRef[InterconnectLocationCrossSiteInterconnectInfo()];

coerce 'RepeatedInterconnectLocationCrossSiteInterconnectInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectLocationCrossSiteInterconnectInfo'->new($_) } @$_ ] };

declare 'MapStringInterconnectLocationCrossSiteInterconnectInfo',
    as HashRef[InterconnectLocationCrossSiteInterconnectInfo()];

declare 'InterconnectLocationList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectLocationList'];

coerce 'InterconnectLocationList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectLocationList'->new($_) };

declare 'RepeatedInterconnectLocationList',
    as ArrayRef[InterconnectLocationList()];

coerce 'RepeatedInterconnectLocationList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectLocationList'->new($_) } @$_ ] };

declare 'MapStringInterconnectLocationList',
    as HashRef[InterconnectLocationList()];

declare 'InterconnectLocationRegionInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectLocationRegionInfo'];

coerce 'InterconnectLocationRegionInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectLocationRegionInfo'->new($_) };

declare 'RepeatedInterconnectLocationRegionInfo',
    as ArrayRef[InterconnectLocationRegionInfo()];

coerce 'RepeatedInterconnectLocationRegionInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectLocationRegionInfo'->new($_) } @$_ ] };

declare 'MapStringInterconnectLocationRegionInfo',
    as HashRef[InterconnectLocationRegionInfo()];

declare 'LocationPresence',
    as (Int | Str);

declare 'InterconnectMacsec',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectMacsec'];

coerce 'InterconnectMacsec',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsec'->new($_) };

declare 'RepeatedInterconnectMacsec',
    as ArrayRef[InterconnectMacsec()];

coerce 'RepeatedInterconnectMacsec',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsec'->new($_) } @$_ ] };

declare 'MapStringInterconnectMacsec',
    as HashRef[InterconnectMacsec()];

declare 'InterconnectMacsecConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectMacsecConfig'];

coerce 'InterconnectMacsecConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsecConfig'->new($_) };

declare 'RepeatedInterconnectMacsecConfig',
    as ArrayRef[InterconnectMacsecConfig()];

coerce 'RepeatedInterconnectMacsecConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsecConfig'->new($_) } @$_ ] };

declare 'MapStringInterconnectMacsecConfig',
    as HashRef[InterconnectMacsecConfig()];

declare 'InterconnectMacsecConfigPreSharedKey',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectMacsecConfigPreSharedKey'];

coerce 'InterconnectMacsecConfigPreSharedKey',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsecConfigPreSharedKey'->new($_) };

declare 'RepeatedInterconnectMacsecConfigPreSharedKey',
    as ArrayRef[InterconnectMacsecConfigPreSharedKey()];

coerce 'RepeatedInterconnectMacsecConfigPreSharedKey',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsecConfigPreSharedKey'->new($_) } @$_ ] };

declare 'MapStringInterconnectMacsecConfigPreSharedKey',
    as HashRef[InterconnectMacsecConfigPreSharedKey()];

declare 'InterconnectMacsecPreSharedKey',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectMacsecPreSharedKey'];

coerce 'InterconnectMacsecPreSharedKey',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsecPreSharedKey'->new($_) };

declare 'RepeatedInterconnectMacsecPreSharedKey',
    as ArrayRef[InterconnectMacsecPreSharedKey()];

coerce 'RepeatedInterconnectMacsecPreSharedKey',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectMacsecPreSharedKey'->new($_) } @$_ ] };

declare 'MapStringInterconnectMacsecPreSharedKey',
    as HashRef[InterconnectMacsecPreSharedKey()];

declare 'InterconnectOutageNotification',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectOutageNotification'];

coerce 'InterconnectOutageNotification',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectOutageNotification'->new($_) };

declare 'RepeatedInterconnectOutageNotification',
    as ArrayRef[InterconnectOutageNotification()];

coerce 'RepeatedInterconnectOutageNotification',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectOutageNotification'->new($_) } @$_ ] };

declare 'MapStringInterconnectOutageNotification',
    as HashRef[InterconnectOutageNotification()];

declare 'IssueType',
    as (Int | Str);

declare 'Source',
    as (Int | Str);

declare 'State',
    as (Int | Str);

declare 'InterconnectParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectParams'];

coerce 'InterconnectParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectParams'->new($_) };

declare 'RepeatedInterconnectParams',
    as ArrayRef[InterconnectParams()];

coerce 'RepeatedInterconnectParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectParams'->new($_) } @$_ ] };

declare 'MapStringInterconnectParams',
    as HashRef[InterconnectParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'InterconnectRemoteLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocation'];

coerce 'InterconnectRemoteLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocation'->new($_) };

declare 'RepeatedInterconnectRemoteLocation',
    as ArrayRef[InterconnectRemoteLocation()];

coerce 'RepeatedInterconnectRemoteLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocation'->new($_) } @$_ ] };

declare 'MapStringInterconnectRemoteLocation',
    as HashRef[InterconnectRemoteLocation()];

declare 'Continent',
    as (Int | Str);

declare 'Lacp',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'InterconnectRemoteLocationConstraints',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationConstraints'];

coerce 'InterconnectRemoteLocationConstraints',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationConstraints'->new($_) };

declare 'RepeatedInterconnectRemoteLocationConstraints',
    as ArrayRef[InterconnectRemoteLocationConstraints()];

coerce 'RepeatedInterconnectRemoteLocationConstraints',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationConstraints'->new($_) } @$_ ] };

declare 'MapStringInterconnectRemoteLocationConstraints',
    as HashRef[InterconnectRemoteLocationConstraints()];

declare 'PortPairRemoteLocation',
    as (Int | Str);

declare 'PortPairVlan',
    as (Int | Str);

declare 'InterconnectRemoteLocationConstraintsSubnetLengthRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationConstraintsSubnetLengthRange'];

coerce 'InterconnectRemoteLocationConstraintsSubnetLengthRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationConstraintsSubnetLengthRange'->new($_) };

declare 'RepeatedInterconnectRemoteLocationConstraintsSubnetLengthRange',
    as ArrayRef[InterconnectRemoteLocationConstraintsSubnetLengthRange()];

coerce 'RepeatedInterconnectRemoteLocationConstraintsSubnetLengthRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationConstraintsSubnetLengthRange'->new($_) } @$_ ] };

declare 'MapStringInterconnectRemoteLocationConstraintsSubnetLengthRange',
    as HashRef[InterconnectRemoteLocationConstraintsSubnetLengthRange()];

declare 'InterconnectRemoteLocationList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationList'];

coerce 'InterconnectRemoteLocationList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationList'->new($_) };

declare 'RepeatedInterconnectRemoteLocationList',
    as ArrayRef[InterconnectRemoteLocationList()];

coerce 'RepeatedInterconnectRemoteLocationList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationList'->new($_) } @$_ ] };

declare 'MapStringInterconnectRemoteLocationList',
    as HashRef[InterconnectRemoteLocationList()];

declare 'InterconnectRemoteLocationPermittedConnections',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationPermittedConnections'];

coerce 'InterconnectRemoteLocationPermittedConnections',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationPermittedConnections'->new($_) };

declare 'RepeatedInterconnectRemoteLocationPermittedConnections',
    as ArrayRef[InterconnectRemoteLocationPermittedConnections()];

coerce 'RepeatedInterconnectRemoteLocationPermittedConnections',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectRemoteLocationPermittedConnections'->new($_) } @$_ ] };

declare 'MapStringInterconnectRemoteLocationPermittedConnections',
    as HashRef[InterconnectRemoteLocationPermittedConnections()];

declare 'InterconnectsGetDiagnosticsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectsGetDiagnosticsResponse'];

coerce 'InterconnectsGetDiagnosticsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectsGetDiagnosticsResponse'->new($_) };

declare 'RepeatedInterconnectsGetDiagnosticsResponse',
    as ArrayRef[InterconnectsGetDiagnosticsResponse()];

coerce 'RepeatedInterconnectsGetDiagnosticsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectsGetDiagnosticsResponse'->new($_) } @$_ ] };

declare 'MapStringInterconnectsGetDiagnosticsResponse',
    as HashRef[InterconnectsGetDiagnosticsResponse()];

declare 'InterconnectsGetMacsecConfigResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InterconnectsGetMacsecConfigResponse'];

coerce 'InterconnectsGetMacsecConfigResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InterconnectsGetMacsecConfigResponse'->new($_) };

declare 'RepeatedInterconnectsGetMacsecConfigResponse',
    as ArrayRef[InterconnectsGetMacsecConfigResponse()];

coerce 'RepeatedInterconnectsGetMacsecConfigResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InterconnectsGetMacsecConfigResponse'->new($_) } @$_ ] };

declare 'MapStringInterconnectsGetMacsecConfigResponse',
    as HashRef[InterconnectsGetMacsecConfigResponse()];

declare 'InvalidateCacheUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::InvalidateCacheUrlMapRequest'];

coerce 'InvalidateCacheUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::InvalidateCacheUrlMapRequest'->new($_) };

declare 'RepeatedInvalidateCacheUrlMapRequest',
    as ArrayRef[InvalidateCacheUrlMapRequest()];

coerce 'RepeatedInvalidateCacheUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::InvalidateCacheUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringInvalidateCacheUrlMapRequest',
    as HashRef[InvalidateCacheUrlMapRequest()];

declare 'Items',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Items'];

coerce 'Items',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Items'->new($_) };

declare 'RepeatedItems',
    as ArrayRef[Items()];

coerce 'RepeatedItems',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Items'->new($_) } @$_ ] };

declare 'MapStringItems',
    as HashRef[Items()];

declare 'License',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::License'];

coerce 'License',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::License'->new($_) };

declare 'RepeatedLicense',
    as ArrayRef[License()];

coerce 'RepeatedLicense',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::License'->new($_) } @$_ ] };

declare 'MapStringLicense',
    as HashRef[License()];

declare 'LicenseCode',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LicenseCode'];

coerce 'LicenseCode',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LicenseCode'->new($_) };

declare 'RepeatedLicenseCode',
    as ArrayRef[LicenseCode()];

coerce 'RepeatedLicenseCode',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LicenseCode'->new($_) } @$_ ] };

declare 'MapStringLicenseCode',
    as HashRef[LicenseCode()];

declare 'State',
    as (Int | Str);

declare 'LicenseCodeLicenseAlias',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LicenseCodeLicenseAlias'];

coerce 'LicenseCodeLicenseAlias',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LicenseCodeLicenseAlias'->new($_) };

declare 'RepeatedLicenseCodeLicenseAlias',
    as ArrayRef[LicenseCodeLicenseAlias()];

coerce 'RepeatedLicenseCodeLicenseAlias',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LicenseCodeLicenseAlias'->new($_) } @$_ ] };

declare 'MapStringLicenseCodeLicenseAlias',
    as HashRef[LicenseCodeLicenseAlias()];

declare 'LicenseParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LicenseParams'];

coerce 'LicenseParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LicenseParams'->new($_) };

declare 'RepeatedLicenseParams',
    as ArrayRef[LicenseParams()];

coerce 'RepeatedLicenseParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LicenseParams'->new($_) } @$_ ] };

declare 'MapStringLicenseParams',
    as HashRef[LicenseParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LicenseParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LicenseParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LicenseParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'LicenseResourceCommitment',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LicenseResourceCommitment'];

coerce 'LicenseResourceCommitment',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LicenseResourceCommitment'->new($_) };

declare 'RepeatedLicenseResourceCommitment',
    as ArrayRef[LicenseResourceCommitment()];

coerce 'RepeatedLicenseResourceCommitment',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LicenseResourceCommitment'->new($_) } @$_ ] };

declare 'MapStringLicenseResourceCommitment',
    as HashRef[LicenseResourceCommitment()];

declare 'LicenseResourceRequirements',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LicenseResourceRequirements'];

coerce 'LicenseResourceRequirements',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LicenseResourceRequirements'->new($_) };

declare 'RepeatedLicenseResourceRequirements',
    as ArrayRef[LicenseResourceRequirements()];

coerce 'RepeatedLicenseResourceRequirements',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LicenseResourceRequirements'->new($_) } @$_ ] };

declare 'MapStringLicenseResourceRequirements',
    as HashRef[LicenseResourceRequirements()];

declare 'LicensesListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LicensesListResponse'];

coerce 'LicensesListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LicensesListResponse'->new($_) };

declare 'RepeatedLicensesListResponse',
    as ArrayRef[LicensesListResponse()];

coerce 'RepeatedLicensesListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LicensesListResponse'->new($_) } @$_ ] };

declare 'MapStringLicensesListResponse',
    as HashRef[LicensesListResponse()];

declare 'ListAcceleratorTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListAcceleratorTypesRequest'];

coerce 'ListAcceleratorTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListAcceleratorTypesRequest'->new($_) };

declare 'RepeatedListAcceleratorTypesRequest',
    as ArrayRef[ListAcceleratorTypesRequest()];

coerce 'RepeatedListAcceleratorTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListAcceleratorTypesRequest'->new($_) } @$_ ] };

declare 'MapStringListAcceleratorTypesRequest',
    as HashRef[ListAcceleratorTypesRequest()];

declare 'ListAddressesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListAddressesRequest'];

coerce 'ListAddressesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListAddressesRequest'->new($_) };

declare 'RepeatedListAddressesRequest',
    as ArrayRef[ListAddressesRequest()];

coerce 'RepeatedListAddressesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListAddressesRequest'->new($_) } @$_ ] };

declare 'MapStringListAddressesRequest',
    as HashRef[ListAddressesRequest()];

declare 'ListAssociationsFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListAssociationsFirewallPolicyRequest'];

coerce 'ListAssociationsFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListAssociationsFirewallPolicyRequest'->new($_) };

declare 'RepeatedListAssociationsFirewallPolicyRequest',
    as ArrayRef[ListAssociationsFirewallPolicyRequest()];

coerce 'RepeatedListAssociationsFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListAssociationsFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringListAssociationsFirewallPolicyRequest',
    as HashRef[ListAssociationsFirewallPolicyRequest()];

declare 'ListAssociationsOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListAssociationsOrganizationSecurityPolicyRequest'];

coerce 'ListAssociationsOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListAssociationsOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedListAssociationsOrganizationSecurityPolicyRequest',
    as ArrayRef[ListAssociationsOrganizationSecurityPolicyRequest()];

coerce 'RepeatedListAssociationsOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListAssociationsOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringListAssociationsOrganizationSecurityPolicyRequest',
    as HashRef[ListAssociationsOrganizationSecurityPolicyRequest()];

declare 'ListAutoscalersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListAutoscalersRequest'];

coerce 'ListAutoscalersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListAutoscalersRequest'->new($_) };

declare 'RepeatedListAutoscalersRequest',
    as ArrayRef[ListAutoscalersRequest()];

coerce 'RepeatedListAutoscalersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListAutoscalersRequest'->new($_) } @$_ ] };

declare 'MapStringListAutoscalersRequest',
    as HashRef[ListAutoscalersRequest()];

declare 'ListAvailableFeaturesRegionSslPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListAvailableFeaturesRegionSslPoliciesRequest'];

coerce 'ListAvailableFeaturesRegionSslPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListAvailableFeaturesRegionSslPoliciesRequest'->new($_) };

declare 'RepeatedListAvailableFeaturesRegionSslPoliciesRequest',
    as ArrayRef[ListAvailableFeaturesRegionSslPoliciesRequest()];

coerce 'RepeatedListAvailableFeaturesRegionSslPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListAvailableFeaturesRegionSslPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListAvailableFeaturesRegionSslPoliciesRequest',
    as HashRef[ListAvailableFeaturesRegionSslPoliciesRequest()];

declare 'ListAvailableFeaturesSslPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListAvailableFeaturesSslPoliciesRequest'];

coerce 'ListAvailableFeaturesSslPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListAvailableFeaturesSslPoliciesRequest'->new($_) };

declare 'RepeatedListAvailableFeaturesSslPoliciesRequest',
    as ArrayRef[ListAvailableFeaturesSslPoliciesRequest()];

coerce 'RepeatedListAvailableFeaturesSslPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListAvailableFeaturesSslPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListAvailableFeaturesSslPoliciesRequest',
    as HashRef[ListAvailableFeaturesSslPoliciesRequest()];

declare 'ListBackendBucketsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListBackendBucketsRequest'];

coerce 'ListBackendBucketsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListBackendBucketsRequest'->new($_) };

declare 'RepeatedListBackendBucketsRequest',
    as ArrayRef[ListBackendBucketsRequest()];

coerce 'RepeatedListBackendBucketsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListBackendBucketsRequest'->new($_) } @$_ ] };

declare 'MapStringListBackendBucketsRequest',
    as HashRef[ListBackendBucketsRequest()];

declare 'ListBackendServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListBackendServicesRequest'];

coerce 'ListBackendServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListBackendServicesRequest'->new($_) };

declare 'RepeatedListBackendServicesRequest',
    as ArrayRef[ListBackendServicesRequest()];

coerce 'RepeatedListBackendServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListBackendServicesRequest'->new($_) } @$_ ] };

declare 'MapStringListBackendServicesRequest',
    as HashRef[ListBackendServicesRequest()];

declare 'ListBgpRoutesRoutersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListBgpRoutesRoutersRequest'];

coerce 'ListBgpRoutesRoutersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListBgpRoutesRoutersRequest'->new($_) };

declare 'RepeatedListBgpRoutesRoutersRequest',
    as ArrayRef[ListBgpRoutesRoutersRequest()];

coerce 'RepeatedListBgpRoutesRoutersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListBgpRoutesRoutersRequest'->new($_) } @$_ ] };

declare 'MapStringListBgpRoutesRoutersRequest',
    as HashRef[ListBgpRoutesRoutersRequest()];

declare 'AddressFamily',
    as (Int | Str);

declare 'RouteType',
    as (Int | Str);

declare 'ListCrossSiteNetworksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListCrossSiteNetworksRequest'];

coerce 'ListCrossSiteNetworksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListCrossSiteNetworksRequest'->new($_) };

declare 'RepeatedListCrossSiteNetworksRequest',
    as ArrayRef[ListCrossSiteNetworksRequest()];

coerce 'RepeatedListCrossSiteNetworksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListCrossSiteNetworksRequest'->new($_) } @$_ ] };

declare 'MapStringListCrossSiteNetworksRequest',
    as HashRef[ListCrossSiteNetworksRequest()];

declare 'ListDiskTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListDiskTypesRequest'];

coerce 'ListDiskTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListDiskTypesRequest'->new($_) };

declare 'RepeatedListDiskTypesRequest',
    as ArrayRef[ListDiskTypesRequest()];

coerce 'RepeatedListDiskTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListDiskTypesRequest'->new($_) } @$_ ] };

declare 'MapStringListDiskTypesRequest',
    as HashRef[ListDiskTypesRequest()];

declare 'ListDisksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListDisksRequest'];

coerce 'ListDisksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListDisksRequest'->new($_) };

declare 'RepeatedListDisksRequest',
    as ArrayRef[ListDisksRequest()];

coerce 'RepeatedListDisksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListDisksRequest'->new($_) } @$_ ] };

declare 'MapStringListDisksRequest',
    as HashRef[ListDisksRequest()];

declare 'ListDisksStoragePoolsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListDisksStoragePoolsRequest'];

coerce 'ListDisksStoragePoolsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListDisksStoragePoolsRequest'->new($_) };

declare 'RepeatedListDisksStoragePoolsRequest',
    as ArrayRef[ListDisksStoragePoolsRequest()];

coerce 'RepeatedListDisksStoragePoolsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListDisksStoragePoolsRequest'->new($_) } @$_ ] };

declare 'MapStringListDisksStoragePoolsRequest',
    as HashRef[ListDisksStoragePoolsRequest()];

declare 'ListErrorsInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListErrorsInstanceGroupManagersRequest'];

coerce 'ListErrorsInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListErrorsInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListErrorsInstanceGroupManagersRequest',
    as ArrayRef[ListErrorsInstanceGroupManagersRequest()];

coerce 'RepeatedListErrorsInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListErrorsInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListErrorsInstanceGroupManagersRequest',
    as HashRef[ListErrorsInstanceGroupManagersRequest()];

declare 'ListErrorsRegionInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListErrorsRegionInstanceGroupManagersRequest'];

coerce 'ListErrorsRegionInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListErrorsRegionInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListErrorsRegionInstanceGroupManagersRequest',
    as ArrayRef[ListErrorsRegionInstanceGroupManagersRequest()];

coerce 'RepeatedListErrorsRegionInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListErrorsRegionInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListErrorsRegionInstanceGroupManagersRequest',
    as HashRef[ListErrorsRegionInstanceGroupManagersRequest()];

declare 'ListExternalVpnGatewaysRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListExternalVpnGatewaysRequest'];

coerce 'ListExternalVpnGatewaysRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListExternalVpnGatewaysRequest'->new($_) };

declare 'RepeatedListExternalVpnGatewaysRequest',
    as ArrayRef[ListExternalVpnGatewaysRequest()];

coerce 'RepeatedListExternalVpnGatewaysRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListExternalVpnGatewaysRequest'->new($_) } @$_ ] };

declare 'MapStringListExternalVpnGatewaysRequest',
    as HashRef[ListExternalVpnGatewaysRequest()];

declare 'ListFirewallPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListFirewallPoliciesRequest'];

coerce 'ListFirewallPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListFirewallPoliciesRequest'->new($_) };

declare 'RepeatedListFirewallPoliciesRequest',
    as ArrayRef[ListFirewallPoliciesRequest()];

coerce 'RepeatedListFirewallPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListFirewallPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListFirewallPoliciesRequest',
    as HashRef[ListFirewallPoliciesRequest()];

declare 'ListFirewallsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListFirewallsRequest'];

coerce 'ListFirewallsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListFirewallsRequest'->new($_) };

declare 'RepeatedListFirewallsRequest',
    as ArrayRef[ListFirewallsRequest()];

coerce 'RepeatedListFirewallsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListFirewallsRequest'->new($_) } @$_ ] };

declare 'MapStringListFirewallsRequest',
    as HashRef[ListFirewallsRequest()];

declare 'ListForwardingRulesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListForwardingRulesRequest'];

coerce 'ListForwardingRulesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListForwardingRulesRequest'->new($_) };

declare 'RepeatedListForwardingRulesRequest',
    as ArrayRef[ListForwardingRulesRequest()];

coerce 'RepeatedListForwardingRulesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListForwardingRulesRequest'->new($_) } @$_ ] };

declare 'MapStringListForwardingRulesRequest',
    as HashRef[ListForwardingRulesRequest()];

declare 'ListFutureReservationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListFutureReservationsRequest'];

coerce 'ListFutureReservationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListFutureReservationsRequest'->new($_) };

declare 'RepeatedListFutureReservationsRequest',
    as ArrayRef[ListFutureReservationsRequest()];

coerce 'RepeatedListFutureReservationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListFutureReservationsRequest'->new($_) } @$_ ] };

declare 'MapStringListFutureReservationsRequest',
    as HashRef[ListFutureReservationsRequest()];

declare 'ListGlobalAddressesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListGlobalAddressesRequest'];

coerce 'ListGlobalAddressesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListGlobalAddressesRequest'->new($_) };

declare 'RepeatedListGlobalAddressesRequest',
    as ArrayRef[ListGlobalAddressesRequest()];

coerce 'RepeatedListGlobalAddressesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListGlobalAddressesRequest'->new($_) } @$_ ] };

declare 'MapStringListGlobalAddressesRequest',
    as HashRef[ListGlobalAddressesRequest()];

declare 'ListGlobalForwardingRulesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListGlobalForwardingRulesRequest'];

coerce 'ListGlobalForwardingRulesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListGlobalForwardingRulesRequest'->new($_) };

declare 'RepeatedListGlobalForwardingRulesRequest',
    as ArrayRef[ListGlobalForwardingRulesRequest()];

coerce 'RepeatedListGlobalForwardingRulesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListGlobalForwardingRulesRequest'->new($_) } @$_ ] };

declare 'MapStringListGlobalForwardingRulesRequest',
    as HashRef[ListGlobalForwardingRulesRequest()];

declare 'ListGlobalNetworkEndpointGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListGlobalNetworkEndpointGroupsRequest'];

coerce 'ListGlobalNetworkEndpointGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListGlobalNetworkEndpointGroupsRequest'->new($_) };

declare 'RepeatedListGlobalNetworkEndpointGroupsRequest',
    as ArrayRef[ListGlobalNetworkEndpointGroupsRequest()];

coerce 'RepeatedListGlobalNetworkEndpointGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListGlobalNetworkEndpointGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListGlobalNetworkEndpointGroupsRequest',
    as HashRef[ListGlobalNetworkEndpointGroupsRequest()];

declare 'ListGlobalOperationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListGlobalOperationsRequest'];

coerce 'ListGlobalOperationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListGlobalOperationsRequest'->new($_) };

declare 'RepeatedListGlobalOperationsRequest',
    as ArrayRef[ListGlobalOperationsRequest()];

coerce 'RepeatedListGlobalOperationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListGlobalOperationsRequest'->new($_) } @$_ ] };

declare 'MapStringListGlobalOperationsRequest',
    as HashRef[ListGlobalOperationsRequest()];

declare 'ListGlobalOrganizationOperationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListGlobalOrganizationOperationsRequest'];

coerce 'ListGlobalOrganizationOperationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListGlobalOrganizationOperationsRequest'->new($_) };

declare 'RepeatedListGlobalOrganizationOperationsRequest',
    as ArrayRef[ListGlobalOrganizationOperationsRequest()];

coerce 'RepeatedListGlobalOrganizationOperationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListGlobalOrganizationOperationsRequest'->new($_) } @$_ ] };

declare 'MapStringListGlobalOrganizationOperationsRequest',
    as HashRef[ListGlobalOrganizationOperationsRequest()];

declare 'ListGlobalPublicDelegatedPrefixesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListGlobalPublicDelegatedPrefixesRequest'];

coerce 'ListGlobalPublicDelegatedPrefixesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListGlobalPublicDelegatedPrefixesRequest'->new($_) };

declare 'RepeatedListGlobalPublicDelegatedPrefixesRequest',
    as ArrayRef[ListGlobalPublicDelegatedPrefixesRequest()];

coerce 'RepeatedListGlobalPublicDelegatedPrefixesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListGlobalPublicDelegatedPrefixesRequest'->new($_) } @$_ ] };

declare 'MapStringListGlobalPublicDelegatedPrefixesRequest',
    as HashRef[ListGlobalPublicDelegatedPrefixesRequest()];

declare 'ListGlobalVmExtensionPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListGlobalVmExtensionPoliciesRequest'];

coerce 'ListGlobalVmExtensionPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListGlobalVmExtensionPoliciesRequest'->new($_) };

declare 'RepeatedListGlobalVmExtensionPoliciesRequest',
    as ArrayRef[ListGlobalVmExtensionPoliciesRequest()];

coerce 'RepeatedListGlobalVmExtensionPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListGlobalVmExtensionPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListGlobalVmExtensionPoliciesRequest',
    as HashRef[ListGlobalVmExtensionPoliciesRequest()];

declare 'ListHealthChecksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListHealthChecksRequest'];

coerce 'ListHealthChecksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListHealthChecksRequest'->new($_) };

declare 'RepeatedListHealthChecksRequest',
    as ArrayRef[ListHealthChecksRequest()];

coerce 'RepeatedListHealthChecksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListHealthChecksRequest'->new($_) } @$_ ] };

declare 'MapStringListHealthChecksRequest',
    as HashRef[ListHealthChecksRequest()];

declare 'ListImagesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListImagesRequest'];

coerce 'ListImagesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListImagesRequest'->new($_) };

declare 'RepeatedListImagesRequest',
    as ArrayRef[ListImagesRequest()];

coerce 'RepeatedListImagesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListImagesRequest'->new($_) } @$_ ] };

declare 'MapStringListImagesRequest',
    as HashRef[ListImagesRequest()];

declare 'ListInstanceGroupManagerResizeRequestsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstanceGroupManagerResizeRequestsRequest'];

coerce 'ListInstanceGroupManagerResizeRequestsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstanceGroupManagerResizeRequestsRequest'->new($_) };

declare 'RepeatedListInstanceGroupManagerResizeRequestsRequest',
    as ArrayRef[ListInstanceGroupManagerResizeRequestsRequest()];

coerce 'RepeatedListInstanceGroupManagerResizeRequestsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstanceGroupManagerResizeRequestsRequest'->new($_) } @$_ ] };

declare 'MapStringListInstanceGroupManagerResizeRequestsRequest',
    as HashRef[ListInstanceGroupManagerResizeRequestsRequest()];

declare 'ListInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstanceGroupManagersRequest'];

coerce 'ListInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListInstanceGroupManagersRequest',
    as ArrayRef[ListInstanceGroupManagersRequest()];

coerce 'RepeatedListInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListInstanceGroupManagersRequest',
    as HashRef[ListInstanceGroupManagersRequest()];

declare 'ListInstanceGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstanceGroupsRequest'];

coerce 'ListInstanceGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstanceGroupsRequest'->new($_) };

declare 'RepeatedListInstanceGroupsRequest',
    as ArrayRef[ListInstanceGroupsRequest()];

coerce 'RepeatedListInstanceGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstanceGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListInstanceGroupsRequest',
    as HashRef[ListInstanceGroupsRequest()];

declare 'ListInstanceTemplatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstanceTemplatesRequest'];

coerce 'ListInstanceTemplatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstanceTemplatesRequest'->new($_) };

declare 'RepeatedListInstanceTemplatesRequest',
    as ArrayRef[ListInstanceTemplatesRequest()];

coerce 'RepeatedListInstanceTemplatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstanceTemplatesRequest'->new($_) } @$_ ] };

declare 'MapStringListInstanceTemplatesRequest',
    as HashRef[ListInstanceTemplatesRequest()];

declare 'ListInstancesInstanceGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstancesInstanceGroupsRequest'];

coerce 'ListInstancesInstanceGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstancesInstanceGroupsRequest'->new($_) };

declare 'RepeatedListInstancesInstanceGroupsRequest',
    as ArrayRef[ListInstancesInstanceGroupsRequest()];

coerce 'RepeatedListInstancesInstanceGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstancesInstanceGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListInstancesInstanceGroupsRequest',
    as HashRef[ListInstancesInstanceGroupsRequest()];

declare 'ListInstancesRegionInstanceGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstancesRegionInstanceGroupsRequest'];

coerce 'ListInstancesRegionInstanceGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstancesRegionInstanceGroupsRequest'->new($_) };

declare 'RepeatedListInstancesRegionInstanceGroupsRequest',
    as ArrayRef[ListInstancesRegionInstanceGroupsRequest()];

coerce 'RepeatedListInstancesRegionInstanceGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstancesRegionInstanceGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListInstancesRegionInstanceGroupsRequest',
    as HashRef[ListInstancesRegionInstanceGroupsRequest()];

declare 'ListInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstancesRequest'];

coerce 'ListInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstancesRequest'->new($_) };

declare 'RepeatedListInstancesRequest',
    as ArrayRef[ListInstancesRequest()];

coerce 'RepeatedListInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringListInstancesRequest',
    as HashRef[ListInstancesRequest()];

declare 'ListInstantSnapshotGroups',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstantSnapshotGroups'];

coerce 'ListInstantSnapshotGroups',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstantSnapshotGroups'->new($_) };

declare 'RepeatedListInstantSnapshotGroups',
    as ArrayRef[ListInstantSnapshotGroups()];

coerce 'RepeatedListInstantSnapshotGroups',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstantSnapshotGroups'->new($_) } @$_ ] };

declare 'MapStringListInstantSnapshotGroups',
    as HashRef[ListInstantSnapshotGroups()];

declare 'ListInstantSnapshotGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstantSnapshotGroupsRequest'];

coerce 'ListInstantSnapshotGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstantSnapshotGroupsRequest'->new($_) };

declare 'RepeatedListInstantSnapshotGroupsRequest',
    as ArrayRef[ListInstantSnapshotGroupsRequest()];

coerce 'RepeatedListInstantSnapshotGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstantSnapshotGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListInstantSnapshotGroupsRequest',
    as HashRef[ListInstantSnapshotGroupsRequest()];

declare 'ListInstantSnapshotsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInstantSnapshotsRequest'];

coerce 'ListInstantSnapshotsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInstantSnapshotsRequest'->new($_) };

declare 'RepeatedListInstantSnapshotsRequest',
    as ArrayRef[ListInstantSnapshotsRequest()];

coerce 'RepeatedListInstantSnapshotsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInstantSnapshotsRequest'->new($_) } @$_ ] };

declare 'MapStringListInstantSnapshotsRequest',
    as HashRef[ListInstantSnapshotsRequest()];

declare 'ListInterconnectAttachmentGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInterconnectAttachmentGroupsRequest'];

coerce 'ListInterconnectAttachmentGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInterconnectAttachmentGroupsRequest'->new($_) };

declare 'RepeatedListInterconnectAttachmentGroupsRequest',
    as ArrayRef[ListInterconnectAttachmentGroupsRequest()];

coerce 'RepeatedListInterconnectAttachmentGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInterconnectAttachmentGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListInterconnectAttachmentGroupsRequest',
    as HashRef[ListInterconnectAttachmentGroupsRequest()];

declare 'ListInterconnectAttachmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInterconnectAttachmentsRequest'];

coerce 'ListInterconnectAttachmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInterconnectAttachmentsRequest'->new($_) };

declare 'RepeatedListInterconnectAttachmentsRequest',
    as ArrayRef[ListInterconnectAttachmentsRequest()];

coerce 'RepeatedListInterconnectAttachmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInterconnectAttachmentsRequest'->new($_) } @$_ ] };

declare 'MapStringListInterconnectAttachmentsRequest',
    as HashRef[ListInterconnectAttachmentsRequest()];

declare 'ListInterconnectGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInterconnectGroupsRequest'];

coerce 'ListInterconnectGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInterconnectGroupsRequest'->new($_) };

declare 'RepeatedListInterconnectGroupsRequest',
    as ArrayRef[ListInterconnectGroupsRequest()];

coerce 'RepeatedListInterconnectGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInterconnectGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListInterconnectGroupsRequest',
    as HashRef[ListInterconnectGroupsRequest()];

declare 'ListInterconnectLocationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInterconnectLocationsRequest'];

coerce 'ListInterconnectLocationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInterconnectLocationsRequest'->new($_) };

declare 'RepeatedListInterconnectLocationsRequest',
    as ArrayRef[ListInterconnectLocationsRequest()];

coerce 'RepeatedListInterconnectLocationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInterconnectLocationsRequest'->new($_) } @$_ ] };

declare 'MapStringListInterconnectLocationsRequest',
    as HashRef[ListInterconnectLocationsRequest()];

declare 'ListInterconnectRemoteLocationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInterconnectRemoteLocationsRequest'];

coerce 'ListInterconnectRemoteLocationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInterconnectRemoteLocationsRequest'->new($_) };

declare 'RepeatedListInterconnectRemoteLocationsRequest',
    as ArrayRef[ListInterconnectRemoteLocationsRequest()];

coerce 'RepeatedListInterconnectRemoteLocationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInterconnectRemoteLocationsRequest'->new($_) } @$_ ] };

declare 'MapStringListInterconnectRemoteLocationsRequest',
    as HashRef[ListInterconnectRemoteLocationsRequest()];

declare 'ListInterconnectsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListInterconnectsRequest'];

coerce 'ListInterconnectsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListInterconnectsRequest'->new($_) };

declare 'RepeatedListInterconnectsRequest',
    as ArrayRef[ListInterconnectsRequest()];

coerce 'RepeatedListInterconnectsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListInterconnectsRequest'->new($_) } @$_ ] };

declare 'MapStringListInterconnectsRequest',
    as HashRef[ListInterconnectsRequest()];

declare 'ListLicensesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListLicensesRequest'];

coerce 'ListLicensesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListLicensesRequest'->new($_) };

declare 'RepeatedListLicensesRequest',
    as ArrayRef[ListLicensesRequest()];

coerce 'RepeatedListLicensesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListLicensesRequest'->new($_) } @$_ ] };

declare 'MapStringListLicensesRequest',
    as HashRef[ListLicensesRequest()];

declare 'ListMachineImagesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListMachineImagesRequest'];

coerce 'ListMachineImagesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListMachineImagesRequest'->new($_) };

declare 'RepeatedListMachineImagesRequest',
    as ArrayRef[ListMachineImagesRequest()];

coerce 'RepeatedListMachineImagesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListMachineImagesRequest'->new($_) } @$_ ] };

declare 'MapStringListMachineImagesRequest',
    as HashRef[ListMachineImagesRequest()];

declare 'ListMachineTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListMachineTypesRequest'];

coerce 'ListMachineTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListMachineTypesRequest'->new($_) };

declare 'RepeatedListMachineTypesRequest',
    as ArrayRef[ListMachineTypesRequest()];

coerce 'RepeatedListMachineTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListMachineTypesRequest'->new($_) } @$_ ] };

declare 'MapStringListMachineTypesRequest',
    as HashRef[ListMachineTypesRequest()];

declare 'ListManagedInstancesInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListManagedInstancesInstanceGroupManagersRequest'];

coerce 'ListManagedInstancesInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListManagedInstancesInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListManagedInstancesInstanceGroupManagersRequest',
    as ArrayRef[ListManagedInstancesInstanceGroupManagersRequest()];

coerce 'RepeatedListManagedInstancesInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListManagedInstancesInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListManagedInstancesInstanceGroupManagersRequest',
    as HashRef[ListManagedInstancesInstanceGroupManagersRequest()];

declare 'ListManagedInstancesRegionInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListManagedInstancesRegionInstanceGroupManagersRequest'];

coerce 'ListManagedInstancesRegionInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListManagedInstancesRegionInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListManagedInstancesRegionInstanceGroupManagersRequest',
    as ArrayRef[ListManagedInstancesRegionInstanceGroupManagersRequest()];

coerce 'RepeatedListManagedInstancesRegionInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListManagedInstancesRegionInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListManagedInstancesRegionInstanceGroupManagersRequest',
    as HashRef[ListManagedInstancesRegionInstanceGroupManagersRequest()];

declare 'ListNamedSetsRoutersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNamedSetsRoutersRequest'];

coerce 'ListNamedSetsRoutersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNamedSetsRoutersRequest'->new($_) };

declare 'RepeatedListNamedSetsRoutersRequest',
    as ArrayRef[ListNamedSetsRoutersRequest()];

coerce 'RepeatedListNamedSetsRoutersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNamedSetsRoutersRequest'->new($_) } @$_ ] };

declare 'MapStringListNamedSetsRoutersRequest',
    as HashRef[ListNamedSetsRoutersRequest()];

declare 'ListNetworkAttachmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworkAttachmentsRequest'];

coerce 'ListNetworkAttachmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworkAttachmentsRequest'->new($_) };

declare 'RepeatedListNetworkAttachmentsRequest',
    as ArrayRef[ListNetworkAttachmentsRequest()];

coerce 'RepeatedListNetworkAttachmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworkAttachmentsRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworkAttachmentsRequest',
    as HashRef[ListNetworkAttachmentsRequest()];

declare 'ListNetworkEndpointGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworkEndpointGroupsRequest'];

coerce 'ListNetworkEndpointGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointGroupsRequest'->new($_) };

declare 'RepeatedListNetworkEndpointGroupsRequest',
    as ArrayRef[ListNetworkEndpointGroupsRequest()];

coerce 'RepeatedListNetworkEndpointGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworkEndpointGroupsRequest',
    as HashRef[ListNetworkEndpointGroupsRequest()];

declare 'ListNetworkEndpointsGlobalNetworkEndpointGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsGlobalNetworkEndpointGroupsRequest'];

coerce 'ListNetworkEndpointsGlobalNetworkEndpointGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsGlobalNetworkEndpointGroupsRequest'->new($_) };

declare 'RepeatedListNetworkEndpointsGlobalNetworkEndpointGroupsRequest',
    as ArrayRef[ListNetworkEndpointsGlobalNetworkEndpointGroupsRequest()];

coerce 'RepeatedListNetworkEndpointsGlobalNetworkEndpointGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsGlobalNetworkEndpointGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworkEndpointsGlobalNetworkEndpointGroupsRequest',
    as HashRef[ListNetworkEndpointsGlobalNetworkEndpointGroupsRequest()];

declare 'ListNetworkEndpointsNetworkEndpointGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsNetworkEndpointGroupsRequest'];

coerce 'ListNetworkEndpointsNetworkEndpointGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsNetworkEndpointGroupsRequest'->new($_) };

declare 'RepeatedListNetworkEndpointsNetworkEndpointGroupsRequest',
    as ArrayRef[ListNetworkEndpointsNetworkEndpointGroupsRequest()];

coerce 'RepeatedListNetworkEndpointsNetworkEndpointGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsNetworkEndpointGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworkEndpointsNetworkEndpointGroupsRequest',
    as HashRef[ListNetworkEndpointsNetworkEndpointGroupsRequest()];

declare 'ListNetworkEndpointsRegionNetworkEndpointGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsRegionNetworkEndpointGroupsRequest'];

coerce 'ListNetworkEndpointsRegionNetworkEndpointGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsRegionNetworkEndpointGroupsRequest'->new($_) };

declare 'RepeatedListNetworkEndpointsRegionNetworkEndpointGroupsRequest',
    as ArrayRef[ListNetworkEndpointsRegionNetworkEndpointGroupsRequest()];

coerce 'RepeatedListNetworkEndpointsRegionNetworkEndpointGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworkEndpointsRegionNetworkEndpointGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworkEndpointsRegionNetworkEndpointGroupsRequest',
    as HashRef[ListNetworkEndpointsRegionNetworkEndpointGroupsRequest()];

declare 'ListNetworkFirewallPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworkFirewallPoliciesRequest'];

coerce 'ListNetworkFirewallPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworkFirewallPoliciesRequest'->new($_) };

declare 'RepeatedListNetworkFirewallPoliciesRequest',
    as ArrayRef[ListNetworkFirewallPoliciesRequest()];

coerce 'RepeatedListNetworkFirewallPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworkFirewallPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworkFirewallPoliciesRequest',
    as HashRef[ListNetworkFirewallPoliciesRequest()];

declare 'ListNetworkProfilesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworkProfilesRequest'];

coerce 'ListNetworkProfilesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworkProfilesRequest'->new($_) };

declare 'RepeatedListNetworkProfilesRequest',
    as ArrayRef[ListNetworkProfilesRequest()];

coerce 'RepeatedListNetworkProfilesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworkProfilesRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworkProfilesRequest',
    as HashRef[ListNetworkProfilesRequest()];

declare 'ListNetworksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNetworksRequest'];

coerce 'ListNetworksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNetworksRequest'->new($_) };

declare 'RepeatedListNetworksRequest',
    as ArrayRef[ListNetworksRequest()];

coerce 'RepeatedListNetworksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNetworksRequest'->new($_) } @$_ ] };

declare 'MapStringListNetworksRequest',
    as HashRef[ListNetworksRequest()];

declare 'ListNodeGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNodeGroupsRequest'];

coerce 'ListNodeGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNodeGroupsRequest'->new($_) };

declare 'RepeatedListNodeGroupsRequest',
    as ArrayRef[ListNodeGroupsRequest()];

coerce 'RepeatedListNodeGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNodeGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListNodeGroupsRequest',
    as HashRef[ListNodeGroupsRequest()];

declare 'ListNodeTemplatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNodeTemplatesRequest'];

coerce 'ListNodeTemplatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNodeTemplatesRequest'->new($_) };

declare 'RepeatedListNodeTemplatesRequest',
    as ArrayRef[ListNodeTemplatesRequest()];

coerce 'RepeatedListNodeTemplatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNodeTemplatesRequest'->new($_) } @$_ ] };

declare 'MapStringListNodeTemplatesRequest',
    as HashRef[ListNodeTemplatesRequest()];

declare 'ListNodeTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNodeTypesRequest'];

coerce 'ListNodeTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNodeTypesRequest'->new($_) };

declare 'RepeatedListNodeTypesRequest',
    as ArrayRef[ListNodeTypesRequest()];

coerce 'RepeatedListNodeTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNodeTypesRequest'->new($_) } @$_ ] };

declare 'MapStringListNodeTypesRequest',
    as HashRef[ListNodeTypesRequest()];

declare 'ListNodesNodeGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListNodesNodeGroupsRequest'];

coerce 'ListNodesNodeGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListNodesNodeGroupsRequest'->new($_) };

declare 'RepeatedListNodesNodeGroupsRequest',
    as ArrayRef[ListNodesNodeGroupsRequest()];

coerce 'RepeatedListNodesNodeGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListNodesNodeGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListNodesNodeGroupsRequest',
    as HashRef[ListNodesNodeGroupsRequest()];

declare 'ListOrganizationSecurityPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListOrganizationSecurityPoliciesRequest'];

coerce 'ListOrganizationSecurityPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListOrganizationSecurityPoliciesRequest'->new($_) };

declare 'RepeatedListOrganizationSecurityPoliciesRequest',
    as ArrayRef[ListOrganizationSecurityPoliciesRequest()];

coerce 'RepeatedListOrganizationSecurityPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListOrganizationSecurityPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListOrganizationSecurityPoliciesRequest',
    as HashRef[ListOrganizationSecurityPoliciesRequest()];

declare 'ListPacketMirroringsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPacketMirroringsRequest'];

coerce 'ListPacketMirroringsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPacketMirroringsRequest'->new($_) };

declare 'RepeatedListPacketMirroringsRequest',
    as ArrayRef[ListPacketMirroringsRequest()];

coerce 'RepeatedListPacketMirroringsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPacketMirroringsRequest'->new($_) } @$_ ] };

declare 'MapStringListPacketMirroringsRequest',
    as HashRef[ListPacketMirroringsRequest()];

declare 'ListPeeringRoutesNetworksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPeeringRoutesNetworksRequest'];

coerce 'ListPeeringRoutesNetworksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPeeringRoutesNetworksRequest'->new($_) };

declare 'RepeatedListPeeringRoutesNetworksRequest',
    as ArrayRef[ListPeeringRoutesNetworksRequest()];

coerce 'RepeatedListPeeringRoutesNetworksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPeeringRoutesNetworksRequest'->new($_) } @$_ ] };

declare 'MapStringListPeeringRoutesNetworksRequest',
    as HashRef[ListPeeringRoutesNetworksRequest()];

declare 'Direction',
    as (Int | Str);

declare 'ListPerInstanceConfigsInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPerInstanceConfigsInstanceGroupManagersRequest'];

coerce 'ListPerInstanceConfigsInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPerInstanceConfigsInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListPerInstanceConfigsInstanceGroupManagersRequest',
    as ArrayRef[ListPerInstanceConfigsInstanceGroupManagersRequest()];

coerce 'RepeatedListPerInstanceConfigsInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPerInstanceConfigsInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListPerInstanceConfigsInstanceGroupManagersRequest',
    as HashRef[ListPerInstanceConfigsInstanceGroupManagersRequest()];

declare 'ListPerInstanceConfigsRegionInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPerInstanceConfigsRegionInstanceGroupManagersRequest'];

coerce 'ListPerInstanceConfigsRegionInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPerInstanceConfigsRegionInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListPerInstanceConfigsRegionInstanceGroupManagersRequest',
    as ArrayRef[ListPerInstanceConfigsRegionInstanceGroupManagersRequest()];

coerce 'RepeatedListPerInstanceConfigsRegionInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPerInstanceConfigsRegionInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListPerInstanceConfigsRegionInstanceGroupManagersRequest',
    as HashRef[ListPerInstanceConfigsRegionInstanceGroupManagersRequest()];

declare 'ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest'];

coerce 'ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest'->new($_) };

declare 'RepeatedListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest',
    as ArrayRef[ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest()];

coerce 'RepeatedListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest',
    as HashRef[ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest()];

declare 'ListPreconfiguredExpressionSetsSecurityPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPreconfiguredExpressionSetsSecurityPoliciesRequest'];

coerce 'ListPreconfiguredExpressionSetsSecurityPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPreconfiguredExpressionSetsSecurityPoliciesRequest'->new($_) };

declare 'RepeatedListPreconfiguredExpressionSetsSecurityPoliciesRequest',
    as ArrayRef[ListPreconfiguredExpressionSetsSecurityPoliciesRequest()];

coerce 'RepeatedListPreconfiguredExpressionSetsSecurityPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPreconfiguredExpressionSetsSecurityPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListPreconfiguredExpressionSetsSecurityPoliciesRequest',
    as HashRef[ListPreconfiguredExpressionSetsSecurityPoliciesRequest()];

declare 'ListPreviewFeaturesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPreviewFeaturesRequest'];

coerce 'ListPreviewFeaturesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPreviewFeaturesRequest'->new($_) };

declare 'RepeatedListPreviewFeaturesRequest',
    as ArrayRef[ListPreviewFeaturesRequest()];

coerce 'RepeatedListPreviewFeaturesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPreviewFeaturesRequest'->new($_) } @$_ ] };

declare 'MapStringListPreviewFeaturesRequest',
    as HashRef[ListPreviewFeaturesRequest()];

declare 'ListPublicAdvertisedPrefixesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPublicAdvertisedPrefixesRequest'];

coerce 'ListPublicAdvertisedPrefixesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPublicAdvertisedPrefixesRequest'->new($_) };

declare 'RepeatedListPublicAdvertisedPrefixesRequest',
    as ArrayRef[ListPublicAdvertisedPrefixesRequest()];

coerce 'RepeatedListPublicAdvertisedPrefixesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPublicAdvertisedPrefixesRequest'->new($_) } @$_ ] };

declare 'MapStringListPublicAdvertisedPrefixesRequest',
    as HashRef[ListPublicAdvertisedPrefixesRequest()];

declare 'ListPublicDelegatedPrefixesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListPublicDelegatedPrefixesRequest'];

coerce 'ListPublicDelegatedPrefixesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListPublicDelegatedPrefixesRequest'->new($_) };

declare 'RepeatedListPublicDelegatedPrefixesRequest',
    as ArrayRef[ListPublicDelegatedPrefixesRequest()];

coerce 'RepeatedListPublicDelegatedPrefixesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListPublicDelegatedPrefixesRequest'->new($_) } @$_ ] };

declare 'MapStringListPublicDelegatedPrefixesRequest',
    as HashRef[ListPublicDelegatedPrefixesRequest()];

declare 'ListReferrersInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListReferrersInstancesRequest'];

coerce 'ListReferrersInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListReferrersInstancesRequest'->new($_) };

declare 'RepeatedListReferrersInstancesRequest',
    as ArrayRef[ListReferrersInstancesRequest()];

coerce 'RepeatedListReferrersInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListReferrersInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringListReferrersInstancesRequest',
    as HashRef[ListReferrersInstancesRequest()];

declare 'ListRegionAutoscalersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionAutoscalersRequest'];

coerce 'ListRegionAutoscalersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionAutoscalersRequest'->new($_) };

declare 'RepeatedListRegionAutoscalersRequest',
    as ArrayRef[ListRegionAutoscalersRequest()];

coerce 'RepeatedListRegionAutoscalersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionAutoscalersRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionAutoscalersRequest',
    as HashRef[ListRegionAutoscalersRequest()];

declare 'ListRegionBackendBucketsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionBackendBucketsRequest'];

coerce 'ListRegionBackendBucketsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionBackendBucketsRequest'->new($_) };

declare 'RepeatedListRegionBackendBucketsRequest',
    as ArrayRef[ListRegionBackendBucketsRequest()];

coerce 'RepeatedListRegionBackendBucketsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionBackendBucketsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionBackendBucketsRequest',
    as HashRef[ListRegionBackendBucketsRequest()];

declare 'ListRegionBackendServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionBackendServicesRequest'];

coerce 'ListRegionBackendServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionBackendServicesRequest'->new($_) };

declare 'RepeatedListRegionBackendServicesRequest',
    as ArrayRef[ListRegionBackendServicesRequest()];

coerce 'RepeatedListRegionBackendServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionBackendServicesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionBackendServicesRequest',
    as HashRef[ListRegionBackendServicesRequest()];

declare 'ListRegionCommitmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionCommitmentsRequest'];

coerce 'ListRegionCommitmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionCommitmentsRequest'->new($_) };

declare 'RepeatedListRegionCommitmentsRequest',
    as ArrayRef[ListRegionCommitmentsRequest()];

coerce 'RepeatedListRegionCommitmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionCommitmentsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionCommitmentsRequest',
    as HashRef[ListRegionCommitmentsRequest()];

declare 'ListRegionCompositeHealthChecksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionCompositeHealthChecksRequest'];

coerce 'ListRegionCompositeHealthChecksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionCompositeHealthChecksRequest'->new($_) };

declare 'RepeatedListRegionCompositeHealthChecksRequest',
    as ArrayRef[ListRegionCompositeHealthChecksRequest()];

coerce 'RepeatedListRegionCompositeHealthChecksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionCompositeHealthChecksRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionCompositeHealthChecksRequest',
    as HashRef[ListRegionCompositeHealthChecksRequest()];

declare 'ListRegionDiskTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionDiskTypesRequest'];

coerce 'ListRegionDiskTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionDiskTypesRequest'->new($_) };

declare 'RepeatedListRegionDiskTypesRequest',
    as ArrayRef[ListRegionDiskTypesRequest()];

coerce 'RepeatedListRegionDiskTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionDiskTypesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionDiskTypesRequest',
    as HashRef[ListRegionDiskTypesRequest()];

declare 'ListRegionDisksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionDisksRequest'];

coerce 'ListRegionDisksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionDisksRequest'->new($_) };

declare 'RepeatedListRegionDisksRequest',
    as ArrayRef[ListRegionDisksRequest()];

coerce 'RepeatedListRegionDisksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionDisksRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionDisksRequest',
    as HashRef[ListRegionDisksRequest()];

declare 'ListRegionHealthAggregationPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionHealthAggregationPoliciesRequest'];

coerce 'ListRegionHealthAggregationPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthAggregationPoliciesRequest'->new($_) };

declare 'RepeatedListRegionHealthAggregationPoliciesRequest',
    as ArrayRef[ListRegionHealthAggregationPoliciesRequest()];

coerce 'RepeatedListRegionHealthAggregationPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthAggregationPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionHealthAggregationPoliciesRequest',
    as HashRef[ListRegionHealthAggregationPoliciesRequest()];

declare 'ListRegionHealthCheckServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionHealthCheckServicesRequest'];

coerce 'ListRegionHealthCheckServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthCheckServicesRequest'->new($_) };

declare 'RepeatedListRegionHealthCheckServicesRequest',
    as ArrayRef[ListRegionHealthCheckServicesRequest()];

coerce 'RepeatedListRegionHealthCheckServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthCheckServicesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionHealthCheckServicesRequest',
    as HashRef[ListRegionHealthCheckServicesRequest()];

declare 'ListRegionHealthChecksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionHealthChecksRequest'];

coerce 'ListRegionHealthChecksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthChecksRequest'->new($_) };

declare 'RepeatedListRegionHealthChecksRequest',
    as ArrayRef[ListRegionHealthChecksRequest()];

coerce 'RepeatedListRegionHealthChecksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthChecksRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionHealthChecksRequest',
    as HashRef[ListRegionHealthChecksRequest()];

declare 'ListRegionHealthSourcesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionHealthSourcesRequest'];

coerce 'ListRegionHealthSourcesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthSourcesRequest'->new($_) };

declare 'RepeatedListRegionHealthSourcesRequest',
    as ArrayRef[ListRegionHealthSourcesRequest()];

coerce 'RepeatedListRegionHealthSourcesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionHealthSourcesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionHealthSourcesRequest',
    as HashRef[ListRegionHealthSourcesRequest()];

declare 'ListRegionInstanceGroupManagerResizeRequestsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupManagerResizeRequestsRequest'];

coerce 'ListRegionInstanceGroupManagerResizeRequestsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupManagerResizeRequestsRequest'->new($_) };

declare 'RepeatedListRegionInstanceGroupManagerResizeRequestsRequest',
    as ArrayRef[ListRegionInstanceGroupManagerResizeRequestsRequest()];

coerce 'RepeatedListRegionInstanceGroupManagerResizeRequestsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupManagerResizeRequestsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionInstanceGroupManagerResizeRequestsRequest',
    as HashRef[ListRegionInstanceGroupManagerResizeRequestsRequest()];

declare 'ListRegionInstanceGroupManagersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupManagersRequest'];

coerce 'ListRegionInstanceGroupManagersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupManagersRequest'->new($_) };

declare 'RepeatedListRegionInstanceGroupManagersRequest',
    as ArrayRef[ListRegionInstanceGroupManagersRequest()];

coerce 'RepeatedListRegionInstanceGroupManagersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupManagersRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionInstanceGroupManagersRequest',
    as HashRef[ListRegionInstanceGroupManagersRequest()];

declare 'ListRegionInstanceGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupsRequest'];

coerce 'ListRegionInstanceGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupsRequest'->new($_) };

declare 'RepeatedListRegionInstanceGroupsRequest',
    as ArrayRef[ListRegionInstanceGroupsRequest()];

coerce 'RepeatedListRegionInstanceGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionInstanceGroupsRequest',
    as HashRef[ListRegionInstanceGroupsRequest()];

declare 'ListRegionInstanceTemplatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionInstanceTemplatesRequest'];

coerce 'ListRegionInstanceTemplatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceTemplatesRequest'->new($_) };

declare 'RepeatedListRegionInstanceTemplatesRequest',
    as ArrayRef[ListRegionInstanceTemplatesRequest()];

coerce 'RepeatedListRegionInstanceTemplatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionInstanceTemplatesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionInstanceTemplatesRequest',
    as HashRef[ListRegionInstanceTemplatesRequest()];

declare 'ListRegionInstantSnapshotGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionInstantSnapshotGroupsRequest'];

coerce 'ListRegionInstantSnapshotGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionInstantSnapshotGroupsRequest'->new($_) };

declare 'RepeatedListRegionInstantSnapshotGroupsRequest',
    as ArrayRef[ListRegionInstantSnapshotGroupsRequest()];

coerce 'RepeatedListRegionInstantSnapshotGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionInstantSnapshotGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionInstantSnapshotGroupsRequest',
    as HashRef[ListRegionInstantSnapshotGroupsRequest()];

declare 'ListRegionInstantSnapshotsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionInstantSnapshotsRequest'];

coerce 'ListRegionInstantSnapshotsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionInstantSnapshotsRequest'->new($_) };

declare 'RepeatedListRegionInstantSnapshotsRequest',
    as ArrayRef[ListRegionInstantSnapshotsRequest()];

coerce 'RepeatedListRegionInstantSnapshotsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionInstantSnapshotsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionInstantSnapshotsRequest',
    as HashRef[ListRegionInstantSnapshotsRequest()];

declare 'ListRegionNetworkEndpointGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionNetworkEndpointGroupsRequest'];

coerce 'ListRegionNetworkEndpointGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionNetworkEndpointGroupsRequest'->new($_) };

declare 'RepeatedListRegionNetworkEndpointGroupsRequest',
    as ArrayRef[ListRegionNetworkEndpointGroupsRequest()];

coerce 'RepeatedListRegionNetworkEndpointGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionNetworkEndpointGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionNetworkEndpointGroupsRequest',
    as HashRef[ListRegionNetworkEndpointGroupsRequest()];

declare 'ListRegionNetworkFirewallPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionNetworkFirewallPoliciesRequest'];

coerce 'ListRegionNetworkFirewallPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionNetworkFirewallPoliciesRequest'->new($_) };

declare 'RepeatedListRegionNetworkFirewallPoliciesRequest',
    as ArrayRef[ListRegionNetworkFirewallPoliciesRequest()];

coerce 'RepeatedListRegionNetworkFirewallPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionNetworkFirewallPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionNetworkFirewallPoliciesRequest',
    as HashRef[ListRegionNetworkFirewallPoliciesRequest()];

declare 'ListRegionNotificationEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionNotificationEndpointsRequest'];

coerce 'ListRegionNotificationEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionNotificationEndpointsRequest'->new($_) };

declare 'RepeatedListRegionNotificationEndpointsRequest',
    as ArrayRef[ListRegionNotificationEndpointsRequest()];

coerce 'RepeatedListRegionNotificationEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionNotificationEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionNotificationEndpointsRequest',
    as HashRef[ListRegionNotificationEndpointsRequest()];

declare 'ListRegionOperationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionOperationsRequest'];

coerce 'ListRegionOperationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionOperationsRequest'->new($_) };

declare 'RepeatedListRegionOperationsRequest',
    as ArrayRef[ListRegionOperationsRequest()];

coerce 'RepeatedListRegionOperationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionOperationsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionOperationsRequest',
    as HashRef[ListRegionOperationsRequest()];

declare 'ListRegionSecurityPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionSecurityPoliciesRequest'];

coerce 'ListRegionSecurityPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionSecurityPoliciesRequest'->new($_) };

declare 'RepeatedListRegionSecurityPoliciesRequest',
    as ArrayRef[ListRegionSecurityPoliciesRequest()];

coerce 'RepeatedListRegionSecurityPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionSecurityPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionSecurityPoliciesRequest',
    as HashRef[ListRegionSecurityPoliciesRequest()];

declare 'ListRegionSnapshotsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionSnapshotsRequest'];

coerce 'ListRegionSnapshotsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionSnapshotsRequest'->new($_) };

declare 'RepeatedListRegionSnapshotsRequest',
    as ArrayRef[ListRegionSnapshotsRequest()];

coerce 'RepeatedListRegionSnapshotsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionSnapshotsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionSnapshotsRequest',
    as HashRef[ListRegionSnapshotsRequest()];

declare 'ListRegionSslCertificatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionSslCertificatesRequest'];

coerce 'ListRegionSslCertificatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionSslCertificatesRequest'->new($_) };

declare 'RepeatedListRegionSslCertificatesRequest',
    as ArrayRef[ListRegionSslCertificatesRequest()];

coerce 'RepeatedListRegionSslCertificatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionSslCertificatesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionSslCertificatesRequest',
    as HashRef[ListRegionSslCertificatesRequest()];

declare 'ListRegionSslPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionSslPoliciesRequest'];

coerce 'ListRegionSslPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionSslPoliciesRequest'->new($_) };

declare 'RepeatedListRegionSslPoliciesRequest',
    as ArrayRef[ListRegionSslPoliciesRequest()];

coerce 'RepeatedListRegionSslPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionSslPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionSslPoliciesRequest',
    as HashRef[ListRegionSslPoliciesRequest()];

declare 'ListRegionTargetHttpProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionTargetHttpProxiesRequest'];

coerce 'ListRegionTargetHttpProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionTargetHttpProxiesRequest'->new($_) };

declare 'RepeatedListRegionTargetHttpProxiesRequest',
    as ArrayRef[ListRegionTargetHttpProxiesRequest()];

coerce 'RepeatedListRegionTargetHttpProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionTargetHttpProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionTargetHttpProxiesRequest',
    as HashRef[ListRegionTargetHttpProxiesRequest()];

declare 'ListRegionTargetHttpsProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionTargetHttpsProxiesRequest'];

coerce 'ListRegionTargetHttpsProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionTargetHttpsProxiesRequest'->new($_) };

declare 'RepeatedListRegionTargetHttpsProxiesRequest',
    as ArrayRef[ListRegionTargetHttpsProxiesRequest()];

coerce 'RepeatedListRegionTargetHttpsProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionTargetHttpsProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionTargetHttpsProxiesRequest',
    as HashRef[ListRegionTargetHttpsProxiesRequest()];

declare 'ListRegionTargetTcpProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionTargetTcpProxiesRequest'];

coerce 'ListRegionTargetTcpProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionTargetTcpProxiesRequest'->new($_) };

declare 'RepeatedListRegionTargetTcpProxiesRequest',
    as ArrayRef[ListRegionTargetTcpProxiesRequest()];

coerce 'RepeatedListRegionTargetTcpProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionTargetTcpProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionTargetTcpProxiesRequest',
    as HashRef[ListRegionTargetTcpProxiesRequest()];

declare 'ListRegionUrlMapsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionUrlMapsRequest'];

coerce 'ListRegionUrlMapsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionUrlMapsRequest'->new($_) };

declare 'RepeatedListRegionUrlMapsRequest',
    as ArrayRef[ListRegionUrlMapsRequest()];

coerce 'RepeatedListRegionUrlMapsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionUrlMapsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionUrlMapsRequest',
    as HashRef[ListRegionUrlMapsRequest()];

declare 'ListRegionZonesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionZonesRequest'];

coerce 'ListRegionZonesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionZonesRequest'->new($_) };

declare 'RepeatedListRegionZonesRequest',
    as ArrayRef[ListRegionZonesRequest()];

coerce 'RepeatedListRegionZonesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionZonesRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionZonesRequest',
    as HashRef[ListRegionZonesRequest()];

declare 'ListRegionsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRegionsRequest'];

coerce 'ListRegionsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRegionsRequest'->new($_) };

declare 'RepeatedListRegionsRequest',
    as ArrayRef[ListRegionsRequest()];

coerce 'RepeatedListRegionsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRegionsRequest'->new($_) } @$_ ] };

declare 'MapStringListRegionsRequest',
    as HashRef[ListRegionsRequest()];

declare 'ListReservationBlocksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListReservationBlocksRequest'];

coerce 'ListReservationBlocksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListReservationBlocksRequest'->new($_) };

declare 'RepeatedListReservationBlocksRequest',
    as ArrayRef[ListReservationBlocksRequest()];

coerce 'RepeatedListReservationBlocksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListReservationBlocksRequest'->new($_) } @$_ ] };

declare 'MapStringListReservationBlocksRequest',
    as HashRef[ListReservationBlocksRequest()];

declare 'ListReservationSlotsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListReservationSlotsRequest'];

coerce 'ListReservationSlotsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListReservationSlotsRequest'->new($_) };

declare 'RepeatedListReservationSlotsRequest',
    as ArrayRef[ListReservationSlotsRequest()];

coerce 'RepeatedListReservationSlotsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListReservationSlotsRequest'->new($_) } @$_ ] };

declare 'MapStringListReservationSlotsRequest',
    as HashRef[ListReservationSlotsRequest()];

declare 'ListReservationSubBlocksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListReservationSubBlocksRequest'];

coerce 'ListReservationSubBlocksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListReservationSubBlocksRequest'->new($_) };

declare 'RepeatedListReservationSubBlocksRequest',
    as ArrayRef[ListReservationSubBlocksRequest()];

coerce 'RepeatedListReservationSubBlocksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListReservationSubBlocksRequest'->new($_) } @$_ ] };

declare 'MapStringListReservationSubBlocksRequest',
    as HashRef[ListReservationSubBlocksRequest()];

declare 'ListReservationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListReservationsRequest'];

coerce 'ListReservationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListReservationsRequest'->new($_) };

declare 'RepeatedListReservationsRequest',
    as ArrayRef[ListReservationsRequest()];

coerce 'RepeatedListReservationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListReservationsRequest'->new($_) } @$_ ] };

declare 'MapStringListReservationsRequest',
    as HashRef[ListReservationsRequest()];

declare 'ListResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListResourcePoliciesRequest'];

coerce 'ListResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListResourcePoliciesRequest'->new($_) };

declare 'RepeatedListResourcePoliciesRequest',
    as ArrayRef[ListResourcePoliciesRequest()];

coerce 'RepeatedListResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListResourcePoliciesRequest',
    as HashRef[ListResourcePoliciesRequest()];

declare 'ListRolloutPlansRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRolloutPlansRequest'];

coerce 'ListRolloutPlansRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRolloutPlansRequest'->new($_) };

declare 'RepeatedListRolloutPlansRequest',
    as ArrayRef[ListRolloutPlansRequest()];

coerce 'RepeatedListRolloutPlansRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRolloutPlansRequest'->new($_) } @$_ ] };

declare 'MapStringListRolloutPlansRequest',
    as HashRef[ListRolloutPlansRequest()];

declare 'ListRolloutsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRolloutsRequest'];

coerce 'ListRolloutsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRolloutsRequest'->new($_) };

declare 'RepeatedListRolloutsRequest',
    as ArrayRef[ListRolloutsRequest()];

coerce 'RepeatedListRolloutsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRolloutsRequest'->new($_) } @$_ ] };

declare 'MapStringListRolloutsRequest',
    as HashRef[ListRolloutsRequest()];

declare 'ListRoutePoliciesRoutersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRoutePoliciesRoutersRequest'];

coerce 'ListRoutePoliciesRoutersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRoutePoliciesRoutersRequest'->new($_) };

declare 'RepeatedListRoutePoliciesRoutersRequest',
    as ArrayRef[ListRoutePoliciesRoutersRequest()];

coerce 'RepeatedListRoutePoliciesRoutersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRoutePoliciesRoutersRequest'->new($_) } @$_ ] };

declare 'MapStringListRoutePoliciesRoutersRequest',
    as HashRef[ListRoutePoliciesRoutersRequest()];

declare 'ListRoutersRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRoutersRequest'];

coerce 'ListRoutersRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRoutersRequest'->new($_) };

declare 'RepeatedListRoutersRequest',
    as ArrayRef[ListRoutersRequest()];

coerce 'RepeatedListRoutersRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRoutersRequest'->new($_) } @$_ ] };

declare 'MapStringListRoutersRequest',
    as HashRef[ListRoutersRequest()];

declare 'ListRoutesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListRoutesRequest'];

coerce 'ListRoutesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListRoutesRequest'->new($_) };

declare 'RepeatedListRoutesRequest',
    as ArrayRef[ListRoutesRequest()];

coerce 'RepeatedListRoutesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListRoutesRequest'->new($_) } @$_ ] };

declare 'MapStringListRoutesRequest',
    as HashRef[ListRoutesRequest()];

declare 'ListSecurityPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListSecurityPoliciesRequest'];

coerce 'ListSecurityPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListSecurityPoliciesRequest'->new($_) };

declare 'RepeatedListSecurityPoliciesRequest',
    as ArrayRef[ListSecurityPoliciesRequest()];

coerce 'RepeatedListSecurityPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListSecurityPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListSecurityPoliciesRequest',
    as HashRef[ListSecurityPoliciesRequest()];

declare 'ListServiceAttachmentsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListServiceAttachmentsRequest'];

coerce 'ListServiceAttachmentsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListServiceAttachmentsRequest'->new($_) };

declare 'RepeatedListServiceAttachmentsRequest',
    as ArrayRef[ListServiceAttachmentsRequest()];

coerce 'RepeatedListServiceAttachmentsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListServiceAttachmentsRequest'->new($_) } @$_ ] };

declare 'MapStringListServiceAttachmentsRequest',
    as HashRef[ListServiceAttachmentsRequest()];

declare 'ListSnapshotsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListSnapshotsRequest'];

coerce 'ListSnapshotsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListSnapshotsRequest'->new($_) };

declare 'RepeatedListSnapshotsRequest',
    as ArrayRef[ListSnapshotsRequest()];

coerce 'RepeatedListSnapshotsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListSnapshotsRequest'->new($_) } @$_ ] };

declare 'MapStringListSnapshotsRequest',
    as HashRef[ListSnapshotsRequest()];

declare 'ListSslCertificatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListSslCertificatesRequest'];

coerce 'ListSslCertificatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListSslCertificatesRequest'->new($_) };

declare 'RepeatedListSslCertificatesRequest',
    as ArrayRef[ListSslCertificatesRequest()];

coerce 'RepeatedListSslCertificatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListSslCertificatesRequest'->new($_) } @$_ ] };

declare 'MapStringListSslCertificatesRequest',
    as HashRef[ListSslCertificatesRequest()];

declare 'ListSslPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListSslPoliciesRequest'];

coerce 'ListSslPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListSslPoliciesRequest'->new($_) };

declare 'RepeatedListSslPoliciesRequest',
    as ArrayRef[ListSslPoliciesRequest()];

coerce 'RepeatedListSslPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListSslPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListSslPoliciesRequest',
    as HashRef[ListSslPoliciesRequest()];

declare 'ListStoragePoolTypesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListStoragePoolTypesRequest'];

coerce 'ListStoragePoolTypesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListStoragePoolTypesRequest'->new($_) };

declare 'RepeatedListStoragePoolTypesRequest',
    as ArrayRef[ListStoragePoolTypesRequest()];

coerce 'RepeatedListStoragePoolTypesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListStoragePoolTypesRequest'->new($_) } @$_ ] };

declare 'MapStringListStoragePoolTypesRequest',
    as HashRef[ListStoragePoolTypesRequest()];

declare 'ListStoragePoolsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListStoragePoolsRequest'];

coerce 'ListStoragePoolsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListStoragePoolsRequest'->new($_) };

declare 'RepeatedListStoragePoolsRequest',
    as ArrayRef[ListStoragePoolsRequest()];

coerce 'RepeatedListStoragePoolsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListStoragePoolsRequest'->new($_) } @$_ ] };

declare 'MapStringListStoragePoolsRequest',
    as HashRef[ListStoragePoolsRequest()];

declare 'ListSubnetworksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListSubnetworksRequest'];

coerce 'ListSubnetworksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListSubnetworksRequest'->new($_) };

declare 'RepeatedListSubnetworksRequest',
    as ArrayRef[ListSubnetworksRequest()];

coerce 'RepeatedListSubnetworksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListSubnetworksRequest'->new($_) } @$_ ] };

declare 'MapStringListSubnetworksRequest',
    as HashRef[ListSubnetworksRequest()];

declare 'Views',
    as (Int | Str);

declare 'ListTargetGrpcProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetGrpcProxiesRequest'];

coerce 'ListTargetGrpcProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetGrpcProxiesRequest'->new($_) };

declare 'RepeatedListTargetGrpcProxiesRequest',
    as ArrayRef[ListTargetGrpcProxiesRequest()];

coerce 'RepeatedListTargetGrpcProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetGrpcProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetGrpcProxiesRequest',
    as HashRef[ListTargetGrpcProxiesRequest()];

declare 'ListTargetHttpProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetHttpProxiesRequest'];

coerce 'ListTargetHttpProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetHttpProxiesRequest'->new($_) };

declare 'RepeatedListTargetHttpProxiesRequest',
    as ArrayRef[ListTargetHttpProxiesRequest()];

coerce 'RepeatedListTargetHttpProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetHttpProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetHttpProxiesRequest',
    as HashRef[ListTargetHttpProxiesRequest()];

declare 'ListTargetHttpsProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetHttpsProxiesRequest'];

coerce 'ListTargetHttpsProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetHttpsProxiesRequest'->new($_) };

declare 'RepeatedListTargetHttpsProxiesRequest',
    as ArrayRef[ListTargetHttpsProxiesRequest()];

coerce 'RepeatedListTargetHttpsProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetHttpsProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetHttpsProxiesRequest',
    as HashRef[ListTargetHttpsProxiesRequest()];

declare 'ListTargetInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetInstancesRequest'];

coerce 'ListTargetInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetInstancesRequest'->new($_) };

declare 'RepeatedListTargetInstancesRequest',
    as ArrayRef[ListTargetInstancesRequest()];

coerce 'RepeatedListTargetInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetInstancesRequest',
    as HashRef[ListTargetInstancesRequest()];

declare 'ListTargetPoolsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetPoolsRequest'];

coerce 'ListTargetPoolsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetPoolsRequest'->new($_) };

declare 'RepeatedListTargetPoolsRequest',
    as ArrayRef[ListTargetPoolsRequest()];

coerce 'RepeatedListTargetPoolsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetPoolsRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetPoolsRequest',
    as HashRef[ListTargetPoolsRequest()];

declare 'ListTargetSslProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetSslProxiesRequest'];

coerce 'ListTargetSslProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetSslProxiesRequest'->new($_) };

declare 'RepeatedListTargetSslProxiesRequest',
    as ArrayRef[ListTargetSslProxiesRequest()];

coerce 'RepeatedListTargetSslProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetSslProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetSslProxiesRequest',
    as HashRef[ListTargetSslProxiesRequest()];

declare 'ListTargetTcpProxiesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetTcpProxiesRequest'];

coerce 'ListTargetTcpProxiesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetTcpProxiesRequest'->new($_) };

declare 'RepeatedListTargetTcpProxiesRequest',
    as ArrayRef[ListTargetTcpProxiesRequest()];

coerce 'RepeatedListTargetTcpProxiesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetTcpProxiesRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetTcpProxiesRequest',
    as HashRef[ListTargetTcpProxiesRequest()];

declare 'ListTargetVpnGatewaysRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListTargetVpnGatewaysRequest'];

coerce 'ListTargetVpnGatewaysRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListTargetVpnGatewaysRequest'->new($_) };

declare 'RepeatedListTargetVpnGatewaysRequest',
    as ArrayRef[ListTargetVpnGatewaysRequest()];

coerce 'RepeatedListTargetVpnGatewaysRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListTargetVpnGatewaysRequest'->new($_) } @$_ ] };

declare 'MapStringListTargetVpnGatewaysRequest',
    as HashRef[ListTargetVpnGatewaysRequest()];

declare 'ListUrlMapsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListUrlMapsRequest'];

coerce 'ListUrlMapsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListUrlMapsRequest'->new($_) };

declare 'RepeatedListUrlMapsRequest',
    as ArrayRef[ListUrlMapsRequest()];

coerce 'RepeatedListUrlMapsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListUrlMapsRequest'->new($_) } @$_ ] };

declare 'MapStringListUrlMapsRequest',
    as HashRef[ListUrlMapsRequest()];

declare 'ListUsableBackendBucketsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListUsableBackendBucketsRequest'];

coerce 'ListUsableBackendBucketsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListUsableBackendBucketsRequest'->new($_) };

declare 'RepeatedListUsableBackendBucketsRequest',
    as ArrayRef[ListUsableBackendBucketsRequest()];

coerce 'RepeatedListUsableBackendBucketsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListUsableBackendBucketsRequest'->new($_) } @$_ ] };

declare 'MapStringListUsableBackendBucketsRequest',
    as HashRef[ListUsableBackendBucketsRequest()];

declare 'ListUsableBackendServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListUsableBackendServicesRequest'];

coerce 'ListUsableBackendServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListUsableBackendServicesRequest'->new($_) };

declare 'RepeatedListUsableBackendServicesRequest',
    as ArrayRef[ListUsableBackendServicesRequest()];

coerce 'RepeatedListUsableBackendServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListUsableBackendServicesRequest'->new($_) } @$_ ] };

declare 'MapStringListUsableBackendServicesRequest',
    as HashRef[ListUsableBackendServicesRequest()];

declare 'ListUsableRegionBackendBucketsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListUsableRegionBackendBucketsRequest'];

coerce 'ListUsableRegionBackendBucketsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListUsableRegionBackendBucketsRequest'->new($_) };

declare 'RepeatedListUsableRegionBackendBucketsRequest',
    as ArrayRef[ListUsableRegionBackendBucketsRequest()];

coerce 'RepeatedListUsableRegionBackendBucketsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListUsableRegionBackendBucketsRequest'->new($_) } @$_ ] };

declare 'MapStringListUsableRegionBackendBucketsRequest',
    as HashRef[ListUsableRegionBackendBucketsRequest()];

declare 'ListUsableRegionBackendServicesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListUsableRegionBackendServicesRequest'];

coerce 'ListUsableRegionBackendServicesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListUsableRegionBackendServicesRequest'->new($_) };

declare 'RepeatedListUsableRegionBackendServicesRequest',
    as ArrayRef[ListUsableRegionBackendServicesRequest()];

coerce 'RepeatedListUsableRegionBackendServicesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListUsableRegionBackendServicesRequest'->new($_) } @$_ ] };

declare 'MapStringListUsableRegionBackendServicesRequest',
    as HashRef[ListUsableRegionBackendServicesRequest()];

declare 'ListUsableSubnetworksRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListUsableSubnetworksRequest'];

coerce 'ListUsableSubnetworksRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListUsableSubnetworksRequest'->new($_) };

declare 'RepeatedListUsableSubnetworksRequest',
    as ArrayRef[ListUsableSubnetworksRequest()];

coerce 'RepeatedListUsableSubnetworksRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListUsableSubnetworksRequest'->new($_) } @$_ ] };

declare 'MapStringListUsableSubnetworksRequest',
    as HashRef[ListUsableSubnetworksRequest()];

declare 'ListVpnGatewaysRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListVpnGatewaysRequest'];

coerce 'ListVpnGatewaysRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListVpnGatewaysRequest'->new($_) };

declare 'RepeatedListVpnGatewaysRequest',
    as ArrayRef[ListVpnGatewaysRequest()];

coerce 'RepeatedListVpnGatewaysRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListVpnGatewaysRequest'->new($_) } @$_ ] };

declare 'MapStringListVpnGatewaysRequest',
    as HashRef[ListVpnGatewaysRequest()];

declare 'ListVpnTunnelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListVpnTunnelsRequest'];

coerce 'ListVpnTunnelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListVpnTunnelsRequest'->new($_) };

declare 'RepeatedListVpnTunnelsRequest',
    as ArrayRef[ListVpnTunnelsRequest()];

coerce 'RepeatedListVpnTunnelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListVpnTunnelsRequest'->new($_) } @$_ ] };

declare 'MapStringListVpnTunnelsRequest',
    as HashRef[ListVpnTunnelsRequest()];

declare 'ListWireGroupsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListWireGroupsRequest'];

coerce 'ListWireGroupsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListWireGroupsRequest'->new($_) };

declare 'RepeatedListWireGroupsRequest',
    as ArrayRef[ListWireGroupsRequest()];

coerce 'RepeatedListWireGroupsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListWireGroupsRequest'->new($_) } @$_ ] };

declare 'MapStringListWireGroupsRequest',
    as HashRef[ListWireGroupsRequest()];

declare 'ListXpnHostsProjectsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListXpnHostsProjectsRequest'];

coerce 'ListXpnHostsProjectsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListXpnHostsProjectsRequest'->new($_) };

declare 'RepeatedListXpnHostsProjectsRequest',
    as ArrayRef[ListXpnHostsProjectsRequest()];

coerce 'RepeatedListXpnHostsProjectsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListXpnHostsProjectsRequest'->new($_) } @$_ ] };

declare 'MapStringListXpnHostsProjectsRequest',
    as HashRef[ListXpnHostsProjectsRequest()];

declare 'ListZoneOperationsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListZoneOperationsRequest'];

coerce 'ListZoneOperationsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListZoneOperationsRequest'->new($_) };

declare 'RepeatedListZoneOperationsRequest',
    as ArrayRef[ListZoneOperationsRequest()];

coerce 'RepeatedListZoneOperationsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListZoneOperationsRequest'->new($_) } @$_ ] };

declare 'MapStringListZoneOperationsRequest',
    as HashRef[ListZoneOperationsRequest()];

declare 'ListZoneVmExtensionPoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListZoneVmExtensionPoliciesRequest'];

coerce 'ListZoneVmExtensionPoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListZoneVmExtensionPoliciesRequest'->new($_) };

declare 'RepeatedListZoneVmExtensionPoliciesRequest',
    as ArrayRef[ListZoneVmExtensionPoliciesRequest()];

coerce 'RepeatedListZoneVmExtensionPoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListZoneVmExtensionPoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringListZoneVmExtensionPoliciesRequest',
    as HashRef[ListZoneVmExtensionPoliciesRequest()];

declare 'ListZonesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ListZonesRequest'];

coerce 'ListZonesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ListZonesRequest'->new($_) };

declare 'RepeatedListZonesRequest',
    as ArrayRef[ListZonesRequest()];

coerce 'RepeatedListZonesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ListZonesRequest'->new($_) } @$_ ] };

declare 'MapStringListZonesRequest',
    as HashRef[ListZonesRequest()];

declare 'LocalDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LocalDisk'];

coerce 'LocalDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LocalDisk'->new($_) };

declare 'RepeatedLocalDisk',
    as ArrayRef[LocalDisk()];

coerce 'RepeatedLocalDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LocalDisk'->new($_) } @$_ ] };

declare 'MapStringLocalDisk',
    as HashRef[LocalDisk()];

declare 'LocalizedMessage',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LocalizedMessage'];

coerce 'LocalizedMessage',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LocalizedMessage'->new($_) };

declare 'RepeatedLocalizedMessage',
    as ArrayRef[LocalizedMessage()];

coerce 'RepeatedLocalizedMessage',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LocalizedMessage'->new($_) } @$_ ] };

declare 'MapStringLocalizedMessage',
    as HashRef[LocalizedMessage()];

declare 'LocationPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LocationPolicy'];

coerce 'LocationPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LocationPolicy'->new($_) };

declare 'RepeatedLocationPolicy',
    as ArrayRef[LocationPolicy()];

coerce 'RepeatedLocationPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LocationPolicy'->new($_) } @$_ ] };

declare 'MapStringLocationPolicy',
    as HashRef[LocationPolicy()];

declare 'TargetShape',
    as (Int | Str);

declare 'LocationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LocationPolicy::LocationsEntry'];

coerce 'LocationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LocationPolicy::LocationsEntry'->new($_) };

declare 'RepeatedLocationsEntry',
    as ArrayRef[LocationsEntry()];

coerce 'RepeatedLocationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LocationPolicy::LocationsEntry'->new($_) } @$_ ] };

declare 'MapStringLocationsEntry',
    as HashRef[LocationsEntry()];

declare 'LocationPolicyLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LocationPolicyLocation'];

coerce 'LocationPolicyLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LocationPolicyLocation'->new($_) };

declare 'RepeatedLocationPolicyLocation',
    as ArrayRef[LocationPolicyLocation()];

coerce 'RepeatedLocationPolicyLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LocationPolicyLocation'->new($_) } @$_ ] };

declare 'MapStringLocationPolicyLocation',
    as HashRef[LocationPolicyLocation()];

declare 'Preference',
    as (Int | Str);

declare 'LocationPolicyLocationConstraints',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LocationPolicyLocationConstraints'];

coerce 'LocationPolicyLocationConstraints',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LocationPolicyLocationConstraints'->new($_) };

declare 'RepeatedLocationPolicyLocationConstraints',
    as ArrayRef[LocationPolicyLocationConstraints()];

coerce 'RepeatedLocationPolicyLocationConstraints',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LocationPolicyLocationConstraints'->new($_) } @$_ ] };

declare 'MapStringLocationPolicyLocationConstraints',
    as HashRef[LocationPolicyLocationConstraints()];

declare 'LocationPolicyZoneConfiguration',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::LocationPolicyZoneConfiguration'];

coerce 'LocationPolicyZoneConfiguration',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::LocationPolicyZoneConfiguration'->new($_) };

declare 'RepeatedLocationPolicyZoneConfiguration',
    as ArrayRef[LocationPolicyZoneConfiguration()];

coerce 'RepeatedLocationPolicyZoneConfiguration',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::LocationPolicyZoneConfiguration'->new($_) } @$_ ] };

declare 'MapStringLocationPolicyZoneConfiguration',
    as HashRef[LocationPolicyZoneConfiguration()];

declare 'MachineImage',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineImage'];

coerce 'MachineImage',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineImage'->new($_) };

declare 'RepeatedMachineImage',
    as ArrayRef[MachineImage()];

coerce 'RepeatedMachineImage',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineImage'->new($_) } @$_ ] };

declare 'MapStringMachineImage',
    as HashRef[MachineImage()];

declare 'Status',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineImage::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineImage::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineImage::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'MachineImageList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineImageList'];

coerce 'MachineImageList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineImageList'->new($_) };

declare 'RepeatedMachineImageList',
    as ArrayRef[MachineImageList()];

coerce 'RepeatedMachineImageList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineImageList'->new($_) } @$_ ] };

declare 'MapStringMachineImageList',
    as HashRef[MachineImageList()];

declare 'MachineImageParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineImageParams'];

coerce 'MachineImageParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineImageParams'->new($_) };

declare 'RepeatedMachineImageParams',
    as ArrayRef[MachineImageParams()];

coerce 'RepeatedMachineImageParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineImageParams'->new($_) } @$_ ] };

declare 'MapStringMachineImageParams',
    as HashRef[MachineImageParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineImageParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineImageParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineImageParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'MachineType',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineType'];

coerce 'MachineType',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineType'->new($_) };

declare 'RepeatedMachineType',
    as ArrayRef[MachineType()];

coerce 'RepeatedMachineType',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineType'->new($_) } @$_ ] };

declare 'MapStringMachineType',
    as HashRef[MachineType()];

declare 'Architecture',
    as (Int | Str);

declare 'MachineTypeAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineTypeAggregatedList'];

coerce 'MachineTypeAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineTypeAggregatedList'->new($_) };

declare 'RepeatedMachineTypeAggregatedList',
    as ArrayRef[MachineTypeAggregatedList()];

coerce 'RepeatedMachineTypeAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineTypeAggregatedList'->new($_) } @$_ ] };

declare 'MapStringMachineTypeAggregatedList',
    as HashRef[MachineTypeAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineTypeAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineTypeAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineTypeAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'MachineTypeList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineTypeList'];

coerce 'MachineTypeList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineTypeList'->new($_) };

declare 'RepeatedMachineTypeList',
    as ArrayRef[MachineTypeList()];

coerce 'RepeatedMachineTypeList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineTypeList'->new($_) } @$_ ] };

declare 'MapStringMachineTypeList',
    as HashRef[MachineTypeList()];

declare 'MachineTypesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MachineTypesScopedList'];

coerce 'MachineTypesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MachineTypesScopedList'->new($_) };

declare 'RepeatedMachineTypesScopedList',
    as ArrayRef[MachineTypesScopedList()];

coerce 'RepeatedMachineTypesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MachineTypesScopedList'->new($_) } @$_ ] };

declare 'MapStringMachineTypesScopedList',
    as HashRef[MachineTypesScopedList()];

declare 'ManagedInstance',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstance'];

coerce 'ManagedInstance',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstance'->new($_) };

declare 'RepeatedManagedInstance',
    as ArrayRef[ManagedInstance()];

coerce 'RepeatedManagedInstance',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstance'->new($_) } @$_ ] };

declare 'MapStringManagedInstance',
    as HashRef[ManagedInstance()];

declare 'CurrentAction',
    as (Int | Str);

declare 'InstanceStatus',
    as (Int | Str);

declare 'ManagedInstanceInstanceHealth',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstanceInstanceHealth'];

coerce 'ManagedInstanceInstanceHealth',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceInstanceHealth'->new($_) };

declare 'RepeatedManagedInstanceInstanceHealth',
    as ArrayRef[ManagedInstanceInstanceHealth()];

coerce 'RepeatedManagedInstanceInstanceHealth',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceInstanceHealth'->new($_) } @$_ ] };

declare 'MapStringManagedInstanceInstanceHealth',
    as HashRef[ManagedInstanceInstanceHealth()];

declare 'DetailedHealthState',
    as (Int | Str);

declare 'ManagedInstanceLastAttempt',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstanceLastAttempt'];

coerce 'ManagedInstanceLastAttempt',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceLastAttempt'->new($_) };

declare 'RepeatedManagedInstanceLastAttempt',
    as ArrayRef[ManagedInstanceLastAttempt()];

coerce 'RepeatedManagedInstanceLastAttempt',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceLastAttempt'->new($_) } @$_ ] };

declare 'MapStringManagedInstanceLastAttempt',
    as HashRef[ManagedInstanceLastAttempt()];

declare 'ManagedInstanceLastAttemptErrors',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstanceLastAttemptErrors'];

coerce 'ManagedInstanceLastAttemptErrors',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceLastAttemptErrors'->new($_) };

declare 'RepeatedManagedInstanceLastAttemptErrors',
    as ArrayRef[ManagedInstanceLastAttemptErrors()];

coerce 'RepeatedManagedInstanceLastAttemptErrors',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceLastAttemptErrors'->new($_) } @$_ ] };

declare 'MapStringManagedInstanceLastAttemptErrors',
    as HashRef[ManagedInstanceLastAttemptErrors()];

declare 'ManagedInstancePropertiesFromFlexibilityPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstancePropertiesFromFlexibilityPolicy'];

coerce 'ManagedInstancePropertiesFromFlexibilityPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstancePropertiesFromFlexibilityPolicy'->new($_) };

declare 'RepeatedManagedInstancePropertiesFromFlexibilityPolicy',
    as ArrayRef[ManagedInstancePropertiesFromFlexibilityPolicy()];

coerce 'RepeatedManagedInstancePropertiesFromFlexibilityPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstancePropertiesFromFlexibilityPolicy'->new($_) } @$_ ] };

declare 'MapStringManagedInstancePropertiesFromFlexibilityPolicy',
    as HashRef[ManagedInstancePropertiesFromFlexibilityPolicy()];

declare 'ManagedInstanceScheduling',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstanceScheduling'];

coerce 'ManagedInstanceScheduling',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceScheduling'->new($_) };

declare 'RepeatedManagedInstanceScheduling',
    as ArrayRef[ManagedInstanceScheduling()];

coerce 'RepeatedManagedInstanceScheduling',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceScheduling'->new($_) } @$_ ] };

declare 'MapStringManagedInstanceScheduling',
    as HashRef[ManagedInstanceScheduling()];

declare 'ManagedInstanceShutdownDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstanceShutdownDetails'];

coerce 'ManagedInstanceShutdownDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceShutdownDetails'->new($_) };

declare 'RepeatedManagedInstanceShutdownDetails',
    as ArrayRef[ManagedInstanceShutdownDetails()];

coerce 'RepeatedManagedInstanceShutdownDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceShutdownDetails'->new($_) } @$_ ] };

declare 'MapStringManagedInstanceShutdownDetails',
    as HashRef[ManagedInstanceShutdownDetails()];

declare 'ManagedInstanceVersion',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ManagedInstanceVersion'];

coerce 'ManagedInstanceVersion',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceVersion'->new($_) };

declare 'RepeatedManagedInstanceVersion',
    as ArrayRef[ManagedInstanceVersion()];

coerce 'RepeatedManagedInstanceVersion',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ManagedInstanceVersion'->new($_) } @$_ ] };

declare 'MapStringManagedInstanceVersion',
    as HashRef[ManagedInstanceVersion()];

declare 'Metadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Metadata'];

coerce 'Metadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Metadata'->new($_) };

declare 'RepeatedMetadata',
    as ArrayRef[Metadata()];

coerce 'RepeatedMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Metadata'->new($_) } @$_ ] };

declare 'MapStringMetadata',
    as HashRef[Metadata()];

declare 'MetadataFilter',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MetadataFilter'];

coerce 'MetadataFilter',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MetadataFilter'->new($_) };

declare 'RepeatedMetadataFilter',
    as ArrayRef[MetadataFilter()];

coerce 'RepeatedMetadataFilter',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MetadataFilter'->new($_) } @$_ ] };

declare 'MapStringMetadataFilter',
    as HashRef[MetadataFilter()];

declare 'FilterMatchCriteria',
    as (Int | Str);

declare 'MetadataFilterLabelMatch',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MetadataFilterLabelMatch'];

coerce 'MetadataFilterLabelMatch',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MetadataFilterLabelMatch'->new($_) };

declare 'RepeatedMetadataFilterLabelMatch',
    as ArrayRef[MetadataFilterLabelMatch()];

coerce 'RepeatedMetadataFilterLabelMatch',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MetadataFilterLabelMatch'->new($_) } @$_ ] };

declare 'MapStringMetadataFilterLabelMatch',
    as HashRef[MetadataFilterLabelMatch()];

declare 'MoveAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MoveAddressRequest'];

coerce 'MoveAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MoveAddressRequest'->new($_) };

declare 'RepeatedMoveAddressRequest',
    as ArrayRef[MoveAddressRequest()];

coerce 'RepeatedMoveAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MoveAddressRequest'->new($_) } @$_ ] };

declare 'MapStringMoveAddressRequest',
    as HashRef[MoveAddressRequest()];

declare 'MoveDiskProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MoveDiskProjectRequest'];

coerce 'MoveDiskProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MoveDiskProjectRequest'->new($_) };

declare 'RepeatedMoveDiskProjectRequest',
    as ArrayRef[MoveDiskProjectRequest()];

coerce 'RepeatedMoveDiskProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MoveDiskProjectRequest'->new($_) } @$_ ] };

declare 'MapStringMoveDiskProjectRequest',
    as HashRef[MoveDiskProjectRequest()];

declare 'MoveFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MoveFirewallPolicyRequest'];

coerce 'MoveFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MoveFirewallPolicyRequest'->new($_) };

declare 'RepeatedMoveFirewallPolicyRequest',
    as ArrayRef[MoveFirewallPolicyRequest()];

coerce 'RepeatedMoveFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MoveFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringMoveFirewallPolicyRequest',
    as HashRef[MoveFirewallPolicyRequest()];

declare 'MoveGlobalAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MoveGlobalAddressRequest'];

coerce 'MoveGlobalAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MoveGlobalAddressRequest'->new($_) };

declare 'RepeatedMoveGlobalAddressRequest',
    as ArrayRef[MoveGlobalAddressRequest()];

coerce 'RepeatedMoveGlobalAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MoveGlobalAddressRequest'->new($_) } @$_ ] };

declare 'MapStringMoveGlobalAddressRequest',
    as HashRef[MoveGlobalAddressRequest()];

declare 'MoveInstanceProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MoveInstanceProjectRequest'];

coerce 'MoveInstanceProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MoveInstanceProjectRequest'->new($_) };

declare 'RepeatedMoveInstanceProjectRequest',
    as ArrayRef[MoveInstanceProjectRequest()];

coerce 'RepeatedMoveInstanceProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MoveInstanceProjectRequest'->new($_) } @$_ ] };

declare 'MapStringMoveInstanceProjectRequest',
    as HashRef[MoveInstanceProjectRequest()];

declare 'MoveOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::MoveOrganizationSecurityPolicyRequest'];

coerce 'MoveOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::MoveOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedMoveOrganizationSecurityPolicyRequest',
    as ArrayRef[MoveOrganizationSecurityPolicyRequest()];

coerce 'RepeatedMoveOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::MoveOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringMoveOrganizationSecurityPolicyRequest',
    as HashRef[MoveOrganizationSecurityPolicyRequest()];

declare 'NamedPort',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NamedPort'];

coerce 'NamedPort',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NamedPort'->new($_) };

declare 'RepeatedNamedPort',
    as ArrayRef[NamedPort()];

coerce 'RepeatedNamedPort',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NamedPort'->new($_) } @$_ ] };

declare 'MapStringNamedPort',
    as HashRef[NamedPort()];

declare 'NamedSet',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NamedSet'];

coerce 'NamedSet',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NamedSet'->new($_) };

declare 'RepeatedNamedSet',
    as ArrayRef[NamedSet()];

coerce 'RepeatedNamedSet',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NamedSet'->new($_) } @$_ ] };

declare 'MapStringNamedSet',
    as HashRef[NamedSet()];

declare 'Type',
    as (Int | Str);

declare 'NatIpInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NatIpInfo'];

coerce 'NatIpInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NatIpInfo'->new($_) };

declare 'RepeatedNatIpInfo',
    as ArrayRef[NatIpInfo()];

coerce 'RepeatedNatIpInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NatIpInfo'->new($_) } @$_ ] };

declare 'MapStringNatIpInfo',
    as HashRef[NatIpInfo()];

declare 'NatIpInfoNatIpInfoMapping',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NatIpInfoNatIpInfoMapping'];

coerce 'NatIpInfoNatIpInfoMapping',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NatIpInfoNatIpInfoMapping'->new($_) };

declare 'RepeatedNatIpInfoNatIpInfoMapping',
    as ArrayRef[NatIpInfoNatIpInfoMapping()];

coerce 'RepeatedNatIpInfoNatIpInfoMapping',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NatIpInfoNatIpInfoMapping'->new($_) } @$_ ] };

declare 'MapStringNatIpInfoNatIpInfoMapping',
    as HashRef[NatIpInfoNatIpInfoMapping()];

declare 'Mode',
    as (Int | Str);

declare 'Usage',
    as (Int | Str);

declare 'NatIpInfoResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NatIpInfoResponse'];

coerce 'NatIpInfoResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NatIpInfoResponse'->new($_) };

declare 'RepeatedNatIpInfoResponse',
    as ArrayRef[NatIpInfoResponse()];

coerce 'RepeatedNatIpInfoResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NatIpInfoResponse'->new($_) } @$_ ] };

declare 'MapStringNatIpInfoResponse',
    as HashRef[NatIpInfoResponse()];

declare 'Network',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Network'];

coerce 'Network',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Network'->new($_) };

declare 'RepeatedNetwork',
    as ArrayRef[Network()];

coerce 'RepeatedNetwork',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Network'->new($_) } @$_ ] };

declare 'MapStringNetwork',
    as HashRef[Network()];

declare 'NetworkFirewallPolicyEnforcementOrder',
    as (Int | Str);

declare 'NetworkAttachment',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkAttachment'];

coerce 'NetworkAttachment',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkAttachment'->new($_) };

declare 'RepeatedNetworkAttachment',
    as ArrayRef[NetworkAttachment()];

coerce 'RepeatedNetworkAttachment',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkAttachment'->new($_) } @$_ ] };

declare 'MapStringNetworkAttachment',
    as HashRef[NetworkAttachment()];

declare 'ConnectionPreference',
    as (Int | Str);

declare 'NetworkAttachmentAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkAttachmentAggregatedList'];

coerce 'NetworkAttachmentAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentAggregatedList'->new($_) };

declare 'RepeatedNetworkAttachmentAggregatedList',
    as ArrayRef[NetworkAttachmentAggregatedList()];

coerce 'RepeatedNetworkAttachmentAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNetworkAttachmentAggregatedList',
    as HashRef[NetworkAttachmentAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkAttachmentAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NetworkAttachmentConnectedEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkAttachmentConnectedEndpoint'];

coerce 'NetworkAttachmentConnectedEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentConnectedEndpoint'->new($_) };

declare 'RepeatedNetworkAttachmentConnectedEndpoint',
    as ArrayRef[NetworkAttachmentConnectedEndpoint()];

coerce 'RepeatedNetworkAttachmentConnectedEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentConnectedEndpoint'->new($_) } @$_ ] };

declare 'MapStringNetworkAttachmentConnectedEndpoint',
    as HashRef[NetworkAttachmentConnectedEndpoint()];

declare 'Status',
    as (Int | Str);

declare 'NetworkAttachmentList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkAttachmentList'];

coerce 'NetworkAttachmentList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentList'->new($_) };

declare 'RepeatedNetworkAttachmentList',
    as ArrayRef[NetworkAttachmentList()];

coerce 'RepeatedNetworkAttachmentList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentList'->new($_) } @$_ ] };

declare 'MapStringNetworkAttachmentList',
    as HashRef[NetworkAttachmentList()];

declare 'NetworkAttachmentsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkAttachmentsScopedList'];

coerce 'NetworkAttachmentsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentsScopedList'->new($_) };

declare 'RepeatedNetworkAttachmentsScopedList',
    as ArrayRef[NetworkAttachmentsScopedList()];

coerce 'RepeatedNetworkAttachmentsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkAttachmentsScopedList'->new($_) } @$_ ] };

declare 'MapStringNetworkAttachmentsScopedList',
    as HashRef[NetworkAttachmentsScopedList()];

declare 'NetworkEdgeSecurityService',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityService'];

coerce 'NetworkEdgeSecurityService',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityService'->new($_) };

declare 'RepeatedNetworkEdgeSecurityService',
    as ArrayRef[NetworkEdgeSecurityService()];

coerce 'RepeatedNetworkEdgeSecurityService',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityService'->new($_) } @$_ ] };

declare 'MapStringNetworkEdgeSecurityService',
    as HashRef[NetworkEdgeSecurityService()];

declare 'NetworkEdgeSecurityServiceAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServiceAggregatedList'];

coerce 'NetworkEdgeSecurityServiceAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServiceAggregatedList'->new($_) };

declare 'RepeatedNetworkEdgeSecurityServiceAggregatedList',
    as ArrayRef[NetworkEdgeSecurityServiceAggregatedList()];

coerce 'RepeatedNetworkEdgeSecurityServiceAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServiceAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNetworkEdgeSecurityServiceAggregatedList',
    as HashRef[NetworkEdgeSecurityServiceAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServiceAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServiceAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServiceAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NetworkEdgeSecurityServicesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServicesScopedList'];

coerce 'NetworkEdgeSecurityServicesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServicesScopedList'->new($_) };

declare 'RepeatedNetworkEdgeSecurityServicesScopedList',
    as ArrayRef[NetworkEdgeSecurityServicesScopedList()];

coerce 'RepeatedNetworkEdgeSecurityServicesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEdgeSecurityServicesScopedList'->new($_) } @$_ ] };

declare 'MapStringNetworkEdgeSecurityServicesScopedList',
    as HashRef[NetworkEdgeSecurityServicesScopedList()];

declare 'NetworkEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpoint'];

coerce 'NetworkEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpoint'->new($_) };

declare 'RepeatedNetworkEndpoint',
    as ArrayRef[NetworkEndpoint()];

coerce 'RepeatedNetworkEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpoint'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpoint',
    as HashRef[NetworkEndpoint()];

declare 'AnnotationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpoint::AnnotationsEntry'];

coerce 'AnnotationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpoint::AnnotationsEntry'->new($_) };

declare 'RepeatedAnnotationsEntry',
    as ArrayRef[AnnotationsEntry()];

coerce 'RepeatedAnnotationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpoint::AnnotationsEntry'->new($_) } @$_ ] };

declare 'MapStringAnnotationsEntry',
    as HashRef[AnnotationsEntry()];

declare 'NetworkEndpointGroup',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroup'];

coerce 'NetworkEndpointGroup',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroup'->new($_) };

declare 'RepeatedNetworkEndpointGroup',
    as ArrayRef[NetworkEndpointGroup()];

coerce 'RepeatedNetworkEndpointGroup',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroup'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroup',
    as HashRef[NetworkEndpointGroup()];

declare 'NetworkEndpointType',
    as (Int | Str);

declare 'AnnotationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroup::AnnotationsEntry'];

coerce 'AnnotationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroup::AnnotationsEntry'->new($_) };

declare 'RepeatedAnnotationsEntry',
    as ArrayRef[AnnotationsEntry()];

coerce 'RepeatedAnnotationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroup::AnnotationsEntry'->new($_) } @$_ ] };

declare 'MapStringAnnotationsEntry',
    as HashRef[AnnotationsEntry()];

declare 'NetworkEndpointGroupAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAggregatedList'];

coerce 'NetworkEndpointGroupAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAggregatedList'->new($_) };

declare 'RepeatedNetworkEndpointGroupAggregatedList',
    as ArrayRef[NetworkEndpointGroupAggregatedList()];

coerce 'RepeatedNetworkEndpointGroupAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupAggregatedList',
    as HashRef[NetworkEndpointGroupAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NetworkEndpointGroupAppEngine',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAppEngine'];

coerce 'NetworkEndpointGroupAppEngine',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAppEngine'->new($_) };

declare 'RepeatedNetworkEndpointGroupAppEngine',
    as ArrayRef[NetworkEndpointGroupAppEngine()];

coerce 'RepeatedNetworkEndpointGroupAppEngine',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupAppEngine'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupAppEngine',
    as HashRef[NetworkEndpointGroupAppEngine()];

declare 'NetworkEndpointGroupCloudFunction',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupCloudFunction'];

coerce 'NetworkEndpointGroupCloudFunction',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupCloudFunction'->new($_) };

declare 'RepeatedNetworkEndpointGroupCloudFunction',
    as ArrayRef[NetworkEndpointGroupCloudFunction()];

coerce 'RepeatedNetworkEndpointGroupCloudFunction',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupCloudFunction'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupCloudFunction',
    as HashRef[NetworkEndpointGroupCloudFunction()];

declare 'NetworkEndpointGroupCloudRun',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupCloudRun'];

coerce 'NetworkEndpointGroupCloudRun',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupCloudRun'->new($_) };

declare 'RepeatedNetworkEndpointGroupCloudRun',
    as ArrayRef[NetworkEndpointGroupCloudRun()];

coerce 'RepeatedNetworkEndpointGroupCloudRun',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupCloudRun'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupCloudRun',
    as HashRef[NetworkEndpointGroupCloudRun()];

declare 'NetworkEndpointGroupList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupList'];

coerce 'NetworkEndpointGroupList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupList'->new($_) };

declare 'RepeatedNetworkEndpointGroupList',
    as ArrayRef[NetworkEndpointGroupList()];

coerce 'RepeatedNetworkEndpointGroupList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupList'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupList',
    as HashRef[NetworkEndpointGroupList()];

declare 'NetworkEndpointGroupPscData',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupPscData'];

coerce 'NetworkEndpointGroupPscData',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupPscData'->new($_) };

declare 'RepeatedNetworkEndpointGroupPscData',
    as ArrayRef[NetworkEndpointGroupPscData()];

coerce 'RepeatedNetworkEndpointGroupPscData',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupPscData'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupPscData',
    as HashRef[NetworkEndpointGroupPscData()];

declare 'PscConnectionStatus',
    as (Int | Str);

declare 'NetworkEndpointGroupsAttachEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsAttachEndpointsRequest'];

coerce 'NetworkEndpointGroupsAttachEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsAttachEndpointsRequest'->new($_) };

declare 'RepeatedNetworkEndpointGroupsAttachEndpointsRequest',
    as ArrayRef[NetworkEndpointGroupsAttachEndpointsRequest()];

coerce 'RepeatedNetworkEndpointGroupsAttachEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsAttachEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupsAttachEndpointsRequest',
    as HashRef[NetworkEndpointGroupsAttachEndpointsRequest()];

declare 'NetworkEndpointGroupsDetachEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsDetachEndpointsRequest'];

coerce 'NetworkEndpointGroupsDetachEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsDetachEndpointsRequest'->new($_) };

declare 'RepeatedNetworkEndpointGroupsDetachEndpointsRequest',
    as ArrayRef[NetworkEndpointGroupsDetachEndpointsRequest()];

coerce 'RepeatedNetworkEndpointGroupsDetachEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsDetachEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupsDetachEndpointsRequest',
    as HashRef[NetworkEndpointGroupsDetachEndpointsRequest()];

declare 'NetworkEndpointGroupsListEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsListEndpointsRequest'];

coerce 'NetworkEndpointGroupsListEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsListEndpointsRequest'->new($_) };

declare 'RepeatedNetworkEndpointGroupsListEndpointsRequest',
    as ArrayRef[NetworkEndpointGroupsListEndpointsRequest()];

coerce 'RepeatedNetworkEndpointGroupsListEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsListEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupsListEndpointsRequest',
    as HashRef[NetworkEndpointGroupsListEndpointsRequest()];

declare 'HealthStatus',
    as (Int | Str);

declare 'NetworkEndpointGroupsListNetworkEndpoints',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsListNetworkEndpoints'];

coerce 'NetworkEndpointGroupsListNetworkEndpoints',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsListNetworkEndpoints'->new($_) };

declare 'RepeatedNetworkEndpointGroupsListNetworkEndpoints',
    as ArrayRef[NetworkEndpointGroupsListNetworkEndpoints()];

coerce 'RepeatedNetworkEndpointGroupsListNetworkEndpoints',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsListNetworkEndpoints'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupsListNetworkEndpoints',
    as HashRef[NetworkEndpointGroupsListNetworkEndpoints()];

declare 'NetworkEndpointGroupsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsScopedList'];

coerce 'NetworkEndpointGroupsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsScopedList'->new($_) };

declare 'RepeatedNetworkEndpointGroupsScopedList',
    as ArrayRef[NetworkEndpointGroupsScopedList()];

coerce 'RepeatedNetworkEndpointGroupsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointGroupsScopedList'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointGroupsScopedList',
    as HashRef[NetworkEndpointGroupsScopedList()];

declare 'NetworkEndpointWithHealthStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkEndpointWithHealthStatus'];

coerce 'NetworkEndpointWithHealthStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointWithHealthStatus'->new($_) };

declare 'RepeatedNetworkEndpointWithHealthStatus',
    as ArrayRef[NetworkEndpointWithHealthStatus()];

coerce 'RepeatedNetworkEndpointWithHealthStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkEndpointWithHealthStatus'->new($_) } @$_ ] };

declare 'MapStringNetworkEndpointWithHealthStatus',
    as HashRef[NetworkEndpointWithHealthStatus()];

declare 'NetworkFirewallPolicyAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkFirewallPolicyAggregatedList'];

coerce 'NetworkFirewallPolicyAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkFirewallPolicyAggregatedList'->new($_) };

declare 'RepeatedNetworkFirewallPolicyAggregatedList',
    as ArrayRef[NetworkFirewallPolicyAggregatedList()];

coerce 'RepeatedNetworkFirewallPolicyAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkFirewallPolicyAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNetworkFirewallPolicyAggregatedList',
    as HashRef[NetworkFirewallPolicyAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkFirewallPolicyAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkFirewallPolicyAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkFirewallPolicyAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NetworkInterface',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkInterface'];

coerce 'NetworkInterface',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkInterface'->new($_) };

declare 'RepeatedNetworkInterface',
    as ArrayRef[NetworkInterface()];

coerce 'RepeatedNetworkInterface',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkInterface'->new($_) } @$_ ] };

declare 'MapStringNetworkInterface',
    as HashRef[NetworkInterface()];

declare 'IgmpQuery',
    as (Int | Str);

declare 'Ipv6AccessType',
    as (Int | Str);

declare 'NicType',
    as (Int | Str);

declare 'StackType',
    as (Int | Str);

declare 'NetworkList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkList'];

coerce 'NetworkList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkList'->new($_) };

declare 'RepeatedNetworkList',
    as ArrayRef[NetworkList()];

coerce 'RepeatedNetworkList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkList'->new($_) } @$_ ] };

declare 'MapStringNetworkList',
    as HashRef[NetworkList()];

declare 'NetworkParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkParams'];

coerce 'NetworkParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkParams'->new($_) };

declare 'RepeatedNetworkParams',
    as ArrayRef[NetworkParams()];

coerce 'RepeatedNetworkParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkParams'->new($_) } @$_ ] };

declare 'MapStringNetworkParams',
    as HashRef[NetworkParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'NetworkPeering',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkPeering'];

coerce 'NetworkPeering',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkPeering'->new($_) };

declare 'RepeatedNetworkPeering',
    as ArrayRef[NetworkPeering()];

coerce 'RepeatedNetworkPeering',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkPeering'->new($_) } @$_ ] };

declare 'MapStringNetworkPeering',
    as HashRef[NetworkPeering()];

declare 'StackType',
    as (Int | Str);

declare 'State',
    as (Int | Str);

declare 'UpdateStrategy',
    as (Int | Str);

declare 'NetworkPeeringConnectionStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatus'];

coerce 'NetworkPeeringConnectionStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatus'->new($_) };

declare 'RepeatedNetworkPeeringConnectionStatus',
    as ArrayRef[NetworkPeeringConnectionStatus()];

coerce 'RepeatedNetworkPeeringConnectionStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatus'->new($_) } @$_ ] };

declare 'MapStringNetworkPeeringConnectionStatus',
    as HashRef[NetworkPeeringConnectionStatus()];

declare 'UpdateStrategy',
    as (Int | Str);

declare 'NetworkPeeringConnectionStatusConsensusState',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatusConsensusState'];

coerce 'NetworkPeeringConnectionStatusConsensusState',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatusConsensusState'->new($_) };

declare 'RepeatedNetworkPeeringConnectionStatusConsensusState',
    as ArrayRef[NetworkPeeringConnectionStatusConsensusState()];

coerce 'RepeatedNetworkPeeringConnectionStatusConsensusState',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatusConsensusState'->new($_) } @$_ ] };

declare 'MapStringNetworkPeeringConnectionStatusConsensusState',
    as HashRef[NetworkPeeringConnectionStatusConsensusState()];

declare 'DeleteStatus',
    as (Int | Str);

declare 'UpdateStatus',
    as (Int | Str);

declare 'NetworkPeeringConnectionStatusTrafficConfiguration',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatusTrafficConfiguration'];

coerce 'NetworkPeeringConnectionStatusTrafficConfiguration',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatusTrafficConfiguration'->new($_) };

declare 'RepeatedNetworkPeeringConnectionStatusTrafficConfiguration',
    as ArrayRef[NetworkPeeringConnectionStatusTrafficConfiguration()];

coerce 'RepeatedNetworkPeeringConnectionStatusTrafficConfiguration',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkPeeringConnectionStatusTrafficConfiguration'->new($_) } @$_ ] };

declare 'MapStringNetworkPeeringConnectionStatusTrafficConfiguration',
    as HashRef[NetworkPeeringConnectionStatusTrafficConfiguration()];

declare 'StackType',
    as (Int | Str);

declare 'NetworkPerformanceConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkPerformanceConfig'];

coerce 'NetworkPerformanceConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkPerformanceConfig'->new($_) };

declare 'RepeatedNetworkPerformanceConfig',
    as ArrayRef[NetworkPerformanceConfig()];

coerce 'RepeatedNetworkPerformanceConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkPerformanceConfig'->new($_) } @$_ ] };

declare 'MapStringNetworkPerformanceConfig',
    as HashRef[NetworkPerformanceConfig()];

declare 'TotalEgressBandwidthTier',
    as (Int | Str);

declare 'NetworkProfile',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkProfile'];

coerce 'NetworkProfile',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkProfile'->new($_) };

declare 'RepeatedNetworkProfile',
    as ArrayRef[NetworkProfile()];

coerce 'RepeatedNetworkProfile',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkProfile'->new($_) } @$_ ] };

declare 'MapStringNetworkProfile',
    as HashRef[NetworkProfile()];

declare 'NetworkProfileLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkProfileLocation'];

coerce 'NetworkProfileLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkProfileLocation'->new($_) };

declare 'RepeatedNetworkProfileLocation',
    as ArrayRef[NetworkProfileLocation()];

coerce 'RepeatedNetworkProfileLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkProfileLocation'->new($_) } @$_ ] };

declare 'MapStringNetworkProfileLocation',
    as HashRef[NetworkProfileLocation()];

declare 'Scope',
    as (Int | Str);

declare 'NetworkProfileNetworkFeatures',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkProfileNetworkFeatures'];

coerce 'NetworkProfileNetworkFeatures',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkProfileNetworkFeatures'->new($_) };

declare 'RepeatedNetworkProfileNetworkFeatures',
    as ArrayRef[NetworkProfileNetworkFeatures()];

coerce 'RepeatedNetworkProfileNetworkFeatures',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkProfileNetworkFeatures'->new($_) } @$_ ] };

declare 'MapStringNetworkProfileNetworkFeatures',
    as HashRef[NetworkProfileNetworkFeatures()];

declare 'AddressPurposes',
    as (Int | Str);

declare 'AllowAddressCreation',
    as (Int | Str);

declare 'AllowAliasIpRanges',
    as (Int | Str);

declare 'AllowAutoModeSubnet',
    as (Int | Str);

declare 'AllowClassDFirewalls',
    as (Int | Str);

declare 'AllowCloudNat',
    as (Int | Str);

declare 'AllowCloudRouter',
    as (Int | Str);

declare 'AllowDefaultNicAttachment',
    as (Int | Str);

declare 'AllowExternalIpAccess',
    as (Int | Str);

declare 'AllowFirewallPolicy',
    as (Int | Str);

declare 'AllowInterconnect',
    as (Int | Str);

declare 'AllowIpForwarding',
    as (Int | Str);

declare 'AllowLoadBalancing',
    as (Int | Str);

declare 'AllowMultiNicInSameNetwork',
    as (Int | Str);

declare 'AllowMultiNicInSameSubnetwork',
    as (Int | Str);

declare 'AllowMulticast',
    as (Int | Str);

declare 'AllowNcc',
    as (Int | Str);

declare 'AllowNetworkMigration',
    as (Int | Str);

declare 'AllowPacketMirroring',
    as (Int | Str);

declare 'AllowPrivateGoogleAccess',
    as (Int | Str);

declare 'AllowPsc',
    as (Int | Str);

declare 'AllowSameNetworkUnicast',
    as (Int | Str);

declare 'AllowStaticRoutes',
    as (Int | Str);

declare 'AllowSubInterfaces',
    as (Int | Str);

declare 'AllowSubnetworkCreation',
    as (Int | Str);

declare 'AllowVpcFirewallRules',
    as (Int | Str);

declare 'AllowVpcPeering',
    as (Int | Str);

declare 'AllowVpn',
    as (Int | Str);

declare 'FirewallPolicyTypes',
    as (Int | Str);

declare 'InterfaceTypes',
    as (Int | Str);

declare 'Multicast',
    as (Int | Str);

declare 'SubnetPurposes',
    as (Int | Str);

declare 'SubnetStackTypes',
    as (Int | Str);

declare 'SubnetworkPurposes',
    as (Int | Str);

declare 'SubnetworkStackTypes',
    as (Int | Str);

declare 'Unicast',
    as (Int | Str);

declare 'NetworkProfileNetworkFeaturesPredefinedSubnetworkRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkProfileNetworkFeaturesPredefinedSubnetworkRange'];

coerce 'NetworkProfileNetworkFeaturesPredefinedSubnetworkRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkProfileNetworkFeaturesPredefinedSubnetworkRange'->new($_) };

declare 'RepeatedNetworkProfileNetworkFeaturesPredefinedSubnetworkRange',
    as ArrayRef[NetworkProfileNetworkFeaturesPredefinedSubnetworkRange()];

coerce 'RepeatedNetworkProfileNetworkFeaturesPredefinedSubnetworkRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkProfileNetworkFeaturesPredefinedSubnetworkRange'->new($_) } @$_ ] };

declare 'MapStringNetworkProfileNetworkFeaturesPredefinedSubnetworkRange',
    as HashRef[NetworkProfileNetworkFeaturesPredefinedSubnetworkRange()];

declare 'NetworkProfileProfileType',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkProfileProfileType'];

coerce 'NetworkProfileProfileType',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkProfileProfileType'->new($_) };

declare 'RepeatedNetworkProfileProfileType',
    as ArrayRef[NetworkProfileProfileType()];

coerce 'RepeatedNetworkProfileProfileType',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkProfileProfileType'->new($_) } @$_ ] };

declare 'MapStringNetworkProfileProfileType',
    as HashRef[NetworkProfileProfileType()];

declare 'NetworkType',
    as (Int | Str);

declare 'RdmaSubtype',
    as (Int | Str);

declare 'UllSubtype',
    as (Int | Str);

declare 'VpcSubtype',
    as (Int | Str);

declare 'NetworkProfilesListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkProfilesListResponse'];

coerce 'NetworkProfilesListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkProfilesListResponse'->new($_) };

declare 'RepeatedNetworkProfilesListResponse',
    as ArrayRef[NetworkProfilesListResponse()];

coerce 'RepeatedNetworkProfilesListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkProfilesListResponse'->new($_) } @$_ ] };

declare 'MapStringNetworkProfilesListResponse',
    as HashRef[NetworkProfilesListResponse()];

declare 'NetworkRoutingConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworkRoutingConfig'];

coerce 'NetworkRoutingConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworkRoutingConfig'->new($_) };

declare 'RepeatedNetworkRoutingConfig',
    as ArrayRef[NetworkRoutingConfig()];

coerce 'RepeatedNetworkRoutingConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworkRoutingConfig'->new($_) } @$_ ] };

declare 'MapStringNetworkRoutingConfig',
    as HashRef[NetworkRoutingConfig()];

declare 'BgpBestPathSelectionMode',
    as (Int | Str);

declare 'BgpInterRegionCost',
    as (Int | Str);

declare 'EffectiveBgpInterRegionCost',
    as (Int | Str);

declare 'RoutingMode',
    as (Int | Str);

declare 'NetworksAddPeeringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworksAddPeeringRequest'];

coerce 'NetworksAddPeeringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworksAddPeeringRequest'->new($_) };

declare 'RepeatedNetworksAddPeeringRequest',
    as ArrayRef[NetworksAddPeeringRequest()];

coerce 'RepeatedNetworksAddPeeringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworksAddPeeringRequest'->new($_) } @$_ ] };

declare 'MapStringNetworksAddPeeringRequest',
    as HashRef[NetworksAddPeeringRequest()];

declare 'NetworksCancelRequestRemovePeeringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworksCancelRequestRemovePeeringRequest'];

coerce 'NetworksCancelRequestRemovePeeringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworksCancelRequestRemovePeeringRequest'->new($_) };

declare 'RepeatedNetworksCancelRequestRemovePeeringRequest',
    as ArrayRef[NetworksCancelRequestRemovePeeringRequest()];

coerce 'RepeatedNetworksCancelRequestRemovePeeringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworksCancelRequestRemovePeeringRequest'->new($_) } @$_ ] };

declare 'MapStringNetworksCancelRequestRemovePeeringRequest',
    as HashRef[NetworksCancelRequestRemovePeeringRequest()];

declare 'NetworksGetEffectiveFirewallsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworksGetEffectiveFirewallsResponse'];

coerce 'NetworksGetEffectiveFirewallsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworksGetEffectiveFirewallsResponse'->new($_) };

declare 'RepeatedNetworksGetEffectiveFirewallsResponse',
    as ArrayRef[NetworksGetEffectiveFirewallsResponse()];

coerce 'RepeatedNetworksGetEffectiveFirewallsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworksGetEffectiveFirewallsResponse'->new($_) } @$_ ] };

declare 'MapStringNetworksGetEffectiveFirewallsResponse',
    as HashRef[NetworksGetEffectiveFirewallsResponse()];

declare 'NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy'];

coerce 'NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy'->new($_) };

declare 'RepeatedNetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as ArrayRef[NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy()];

coerce 'RepeatedNetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy'->new($_) } @$_ ] };

declare 'MapStringNetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as HashRef[NetworksGetEffectiveFirewallsResponseEffectiveFirewallPolicy()];

declare 'Type',
    as (Int | Str);

declare 'NetworksRemovePeeringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworksRemovePeeringRequest'];

coerce 'NetworksRemovePeeringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworksRemovePeeringRequest'->new($_) };

declare 'RepeatedNetworksRemovePeeringRequest',
    as ArrayRef[NetworksRemovePeeringRequest()];

coerce 'RepeatedNetworksRemovePeeringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworksRemovePeeringRequest'->new($_) } @$_ ] };

declare 'MapStringNetworksRemovePeeringRequest',
    as HashRef[NetworksRemovePeeringRequest()];

declare 'NetworksRequestRemovePeeringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworksRequestRemovePeeringRequest'];

coerce 'NetworksRequestRemovePeeringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworksRequestRemovePeeringRequest'->new($_) };

declare 'RepeatedNetworksRequestRemovePeeringRequest',
    as ArrayRef[NetworksRequestRemovePeeringRequest()];

coerce 'RepeatedNetworksRequestRemovePeeringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworksRequestRemovePeeringRequest'->new($_) } @$_ ] };

declare 'MapStringNetworksRequestRemovePeeringRequest',
    as HashRef[NetworksRequestRemovePeeringRequest()];

declare 'NetworksUpdatePeeringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NetworksUpdatePeeringRequest'];

coerce 'NetworksUpdatePeeringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NetworksUpdatePeeringRequest'->new($_) };

declare 'RepeatedNetworksUpdatePeeringRequest',
    as ArrayRef[NetworksUpdatePeeringRequest()];

coerce 'RepeatedNetworksUpdatePeeringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NetworksUpdatePeeringRequest'->new($_) } @$_ ] };

declare 'MapStringNetworksUpdatePeeringRequest',
    as HashRef[NetworksUpdatePeeringRequest()];

declare 'NodeGroup',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroup'];

coerce 'NodeGroup',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroup'->new($_) };

declare 'RepeatedNodeGroup',
    as ArrayRef[NodeGroup()];

coerce 'RepeatedNodeGroup',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroup'->new($_) } @$_ ] };

declare 'MapStringNodeGroup',
    as HashRef[NodeGroup()];

declare 'MaintenanceInterval',
    as (Int | Str);

declare 'MaintenancePolicy',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'NodeGroupAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupAggregatedList'];

coerce 'NodeGroupAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupAggregatedList'->new($_) };

declare 'RepeatedNodeGroupAggregatedList',
    as ArrayRef[NodeGroupAggregatedList()];

coerce 'RepeatedNodeGroupAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNodeGroupAggregatedList',
    as HashRef[NodeGroupAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NodeGroupAutoscalingPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupAutoscalingPolicy'];

coerce 'NodeGroupAutoscalingPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupAutoscalingPolicy'->new($_) };

declare 'RepeatedNodeGroupAutoscalingPolicy',
    as ArrayRef[NodeGroupAutoscalingPolicy()];

coerce 'RepeatedNodeGroupAutoscalingPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupAutoscalingPolicy'->new($_) } @$_ ] };

declare 'MapStringNodeGroupAutoscalingPolicy',
    as HashRef[NodeGroupAutoscalingPolicy()];

declare 'Mode',
    as (Int | Str);

declare 'NodeGroupList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupList'];

coerce 'NodeGroupList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupList'->new($_) };

declare 'RepeatedNodeGroupList',
    as ArrayRef[NodeGroupList()];

coerce 'RepeatedNodeGroupList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupList'->new($_) } @$_ ] };

declare 'MapStringNodeGroupList',
    as HashRef[NodeGroupList()];

declare 'NodeGroupMaintenanceWindow',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupMaintenanceWindow'];

coerce 'NodeGroupMaintenanceWindow',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupMaintenanceWindow'->new($_) };

declare 'RepeatedNodeGroupMaintenanceWindow',
    as ArrayRef[NodeGroupMaintenanceWindow()];

coerce 'RepeatedNodeGroupMaintenanceWindow',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupMaintenanceWindow'->new($_) } @$_ ] };

declare 'MapStringNodeGroupMaintenanceWindow',
    as HashRef[NodeGroupMaintenanceWindow()];

declare 'NodeGroupNode',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupNode'];

coerce 'NodeGroupNode',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupNode'->new($_) };

declare 'RepeatedNodeGroupNode',
    as ArrayRef[NodeGroupNode()];

coerce 'RepeatedNodeGroupNode',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupNode'->new($_) } @$_ ] };

declare 'MapStringNodeGroupNode',
    as HashRef[NodeGroupNode()];

declare 'CpuOvercommitType',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'NodeGroupsAddNodesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupsAddNodesRequest'];

coerce 'NodeGroupsAddNodesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupsAddNodesRequest'->new($_) };

declare 'RepeatedNodeGroupsAddNodesRequest',
    as ArrayRef[NodeGroupsAddNodesRequest()];

coerce 'RepeatedNodeGroupsAddNodesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupsAddNodesRequest'->new($_) } @$_ ] };

declare 'MapStringNodeGroupsAddNodesRequest',
    as HashRef[NodeGroupsAddNodesRequest()];

declare 'NodeGroupsDeleteNodesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupsDeleteNodesRequest'];

coerce 'NodeGroupsDeleteNodesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupsDeleteNodesRequest'->new($_) };

declare 'RepeatedNodeGroupsDeleteNodesRequest',
    as ArrayRef[NodeGroupsDeleteNodesRequest()];

coerce 'RepeatedNodeGroupsDeleteNodesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupsDeleteNodesRequest'->new($_) } @$_ ] };

declare 'MapStringNodeGroupsDeleteNodesRequest',
    as HashRef[NodeGroupsDeleteNodesRequest()];

declare 'NodeGroupsListNodes',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupsListNodes'];

coerce 'NodeGroupsListNodes',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupsListNodes'->new($_) };

declare 'RepeatedNodeGroupsListNodes',
    as ArrayRef[NodeGroupsListNodes()];

coerce 'RepeatedNodeGroupsListNodes',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupsListNodes'->new($_) } @$_ ] };

declare 'MapStringNodeGroupsListNodes',
    as HashRef[NodeGroupsListNodes()];

declare 'NodeGroupsPerformMaintenanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupsPerformMaintenanceRequest'];

coerce 'NodeGroupsPerformMaintenanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupsPerformMaintenanceRequest'->new($_) };

declare 'RepeatedNodeGroupsPerformMaintenanceRequest',
    as ArrayRef[NodeGroupsPerformMaintenanceRequest()];

coerce 'RepeatedNodeGroupsPerformMaintenanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupsPerformMaintenanceRequest'->new($_) } @$_ ] };

declare 'MapStringNodeGroupsPerformMaintenanceRequest',
    as HashRef[NodeGroupsPerformMaintenanceRequest()];

declare 'NodeGroupsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupsScopedList'];

coerce 'NodeGroupsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupsScopedList'->new($_) };

declare 'RepeatedNodeGroupsScopedList',
    as ArrayRef[NodeGroupsScopedList()];

coerce 'RepeatedNodeGroupsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupsScopedList'->new($_) } @$_ ] };

declare 'MapStringNodeGroupsScopedList',
    as HashRef[NodeGroupsScopedList()];

declare 'NodeGroupsSetNodeTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupsSetNodeTemplateRequest'];

coerce 'NodeGroupsSetNodeTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupsSetNodeTemplateRequest'->new($_) };

declare 'RepeatedNodeGroupsSetNodeTemplateRequest',
    as ArrayRef[NodeGroupsSetNodeTemplateRequest()];

coerce 'RepeatedNodeGroupsSetNodeTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupsSetNodeTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringNodeGroupsSetNodeTemplateRequest',
    as HashRef[NodeGroupsSetNodeTemplateRequest()];

declare 'NodeGroupsSimulateMaintenanceEventRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeGroupsSimulateMaintenanceEventRequest'];

coerce 'NodeGroupsSimulateMaintenanceEventRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeGroupsSimulateMaintenanceEventRequest'->new($_) };

declare 'RepeatedNodeGroupsSimulateMaintenanceEventRequest',
    as ArrayRef[NodeGroupsSimulateMaintenanceEventRequest()];

coerce 'RepeatedNodeGroupsSimulateMaintenanceEventRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeGroupsSimulateMaintenanceEventRequest'->new($_) } @$_ ] };

declare 'MapStringNodeGroupsSimulateMaintenanceEventRequest',
    as HashRef[NodeGroupsSimulateMaintenanceEventRequest()];

declare 'NodeTemplate',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTemplate'];

coerce 'NodeTemplate',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTemplate'->new($_) };

declare 'RepeatedNodeTemplate',
    as ArrayRef[NodeTemplate()];

coerce 'RepeatedNodeTemplate',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTemplate'->new($_) } @$_ ] };

declare 'MapStringNodeTemplate',
    as HashRef[NodeTemplate()];

declare 'CpuOvercommitType',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'NodeAffinityLabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTemplate::NodeAffinityLabelsEntry'];

coerce 'NodeAffinityLabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTemplate::NodeAffinityLabelsEntry'->new($_) };

declare 'RepeatedNodeAffinityLabelsEntry',
    as ArrayRef[NodeAffinityLabelsEntry()];

coerce 'RepeatedNodeAffinityLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTemplate::NodeAffinityLabelsEntry'->new($_) } @$_ ] };

declare 'MapStringNodeAffinityLabelsEntry',
    as HashRef[NodeAffinityLabelsEntry()];

declare 'NodeTemplateAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTemplateAggregatedList'];

coerce 'NodeTemplateAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTemplateAggregatedList'->new($_) };

declare 'RepeatedNodeTemplateAggregatedList',
    as ArrayRef[NodeTemplateAggregatedList()];

coerce 'RepeatedNodeTemplateAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTemplateAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNodeTemplateAggregatedList',
    as HashRef[NodeTemplateAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTemplateAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTemplateAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTemplateAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NodeTemplateList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTemplateList'];

coerce 'NodeTemplateList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTemplateList'->new($_) };

declare 'RepeatedNodeTemplateList',
    as ArrayRef[NodeTemplateList()];

coerce 'RepeatedNodeTemplateList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTemplateList'->new($_) } @$_ ] };

declare 'MapStringNodeTemplateList',
    as HashRef[NodeTemplateList()];

declare 'NodeTemplateNodeTypeFlexibility',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTemplateNodeTypeFlexibility'];

coerce 'NodeTemplateNodeTypeFlexibility',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTemplateNodeTypeFlexibility'->new($_) };

declare 'RepeatedNodeTemplateNodeTypeFlexibility',
    as ArrayRef[NodeTemplateNodeTypeFlexibility()];

coerce 'RepeatedNodeTemplateNodeTypeFlexibility',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTemplateNodeTypeFlexibility'->new($_) } @$_ ] };

declare 'MapStringNodeTemplateNodeTypeFlexibility',
    as HashRef[NodeTemplateNodeTypeFlexibility()];

declare 'NodeTemplatesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTemplatesScopedList'];

coerce 'NodeTemplatesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTemplatesScopedList'->new($_) };

declare 'RepeatedNodeTemplatesScopedList',
    as ArrayRef[NodeTemplatesScopedList()];

coerce 'RepeatedNodeTemplatesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTemplatesScopedList'->new($_) } @$_ ] };

declare 'MapStringNodeTemplatesScopedList',
    as HashRef[NodeTemplatesScopedList()];

declare 'NodeType',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeType'];

coerce 'NodeType',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeType'->new($_) };

declare 'RepeatedNodeType',
    as ArrayRef[NodeType()];

coerce 'RepeatedNodeType',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeType'->new($_) } @$_ ] };

declare 'MapStringNodeType',
    as HashRef[NodeType()];

declare 'NodeTypeAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTypeAggregatedList'];

coerce 'NodeTypeAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTypeAggregatedList'->new($_) };

declare 'RepeatedNodeTypeAggregatedList',
    as ArrayRef[NodeTypeAggregatedList()];

coerce 'RepeatedNodeTypeAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTypeAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNodeTypeAggregatedList',
    as HashRef[NodeTypeAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTypeAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTypeAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTypeAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NodeTypeList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTypeList'];

coerce 'NodeTypeList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTypeList'->new($_) };

declare 'RepeatedNodeTypeList',
    as ArrayRef[NodeTypeList()];

coerce 'RepeatedNodeTypeList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTypeList'->new($_) } @$_ ] };

declare 'MapStringNodeTypeList',
    as HashRef[NodeTypeList()];

declare 'NodeTypesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NodeTypesScopedList'];

coerce 'NodeTypesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NodeTypesScopedList'->new($_) };

declare 'RepeatedNodeTypesScopedList',
    as ArrayRef[NodeTypesScopedList()];

coerce 'RepeatedNodeTypesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NodeTypesScopedList'->new($_) } @$_ ] };

declare 'MapStringNodeTypesScopedList',
    as HashRef[NodeTypesScopedList()];

declare 'NotificationEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NotificationEndpoint'];

coerce 'NotificationEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NotificationEndpoint'->new($_) };

declare 'RepeatedNotificationEndpoint',
    as ArrayRef[NotificationEndpoint()];

coerce 'RepeatedNotificationEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NotificationEndpoint'->new($_) } @$_ ] };

declare 'MapStringNotificationEndpoint',
    as HashRef[NotificationEndpoint()];

declare 'NotificationEndpointAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NotificationEndpointAggregatedList'];

coerce 'NotificationEndpointAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointAggregatedList'->new($_) };

declare 'RepeatedNotificationEndpointAggregatedList',
    as ArrayRef[NotificationEndpointAggregatedList()];

coerce 'RepeatedNotificationEndpointAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointAggregatedList'->new($_) } @$_ ] };

declare 'MapStringNotificationEndpointAggregatedList',
    as HashRef[NotificationEndpointAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NotificationEndpointAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'NotificationEndpointGrpcSettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NotificationEndpointGrpcSettings'];

coerce 'NotificationEndpointGrpcSettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointGrpcSettings'->new($_) };

declare 'RepeatedNotificationEndpointGrpcSettings',
    as ArrayRef[NotificationEndpointGrpcSettings()];

coerce 'RepeatedNotificationEndpointGrpcSettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointGrpcSettings'->new($_) } @$_ ] };

declare 'MapStringNotificationEndpointGrpcSettings',
    as HashRef[NotificationEndpointGrpcSettings()];

declare 'NotificationEndpointList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NotificationEndpointList'];

coerce 'NotificationEndpointList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointList'->new($_) };

declare 'RepeatedNotificationEndpointList',
    as ArrayRef[NotificationEndpointList()];

coerce 'RepeatedNotificationEndpointList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointList'->new($_) } @$_ ] };

declare 'MapStringNotificationEndpointList',
    as HashRef[NotificationEndpointList()];

declare 'NotificationEndpointsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::NotificationEndpointsScopedList'];

coerce 'NotificationEndpointsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointsScopedList'->new($_) };

declare 'RepeatedNotificationEndpointsScopedList',
    as ArrayRef[NotificationEndpointsScopedList()];

coerce 'RepeatedNotificationEndpointsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::NotificationEndpointsScopedList'->new($_) } @$_ ] };

declare 'MapStringNotificationEndpointsScopedList',
    as HashRef[NotificationEndpointsScopedList()];

declare 'Operation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Operation'];

coerce 'Operation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Operation'->new($_) };

declare 'RepeatedOperation',
    as ArrayRef[Operation()];

coerce 'RepeatedOperation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Operation'->new($_) } @$_ ] };

declare 'MapStringOperation',
    as HashRef[Operation()];

declare 'Status',
    as (Int | Str);

declare 'OperationAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::OperationAggregatedList'];

coerce 'OperationAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::OperationAggregatedList'->new($_) };

declare 'RepeatedOperationAggregatedList',
    as ArrayRef[OperationAggregatedList()];

coerce 'RepeatedOperationAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::OperationAggregatedList'->new($_) } @$_ ] };

declare 'MapStringOperationAggregatedList',
    as HashRef[OperationAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::OperationAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::OperationAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::OperationAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'OperationList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::OperationList'];

coerce 'OperationList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::OperationList'->new($_) };

declare 'RepeatedOperationList',
    as ArrayRef[OperationList()];

coerce 'RepeatedOperationList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::OperationList'->new($_) } @$_ ] };

declare 'MapStringOperationList',
    as HashRef[OperationList()];

declare 'OperationsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::OperationsScopedList'];

coerce 'OperationsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::OperationsScopedList'->new($_) };

declare 'RepeatedOperationsScopedList',
    as ArrayRef[OperationsScopedList()];

coerce 'RepeatedOperationsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::OperationsScopedList'->new($_) } @$_ ] };

declare 'MapStringOperationsScopedList',
    as HashRef[OperationsScopedList()];

declare 'OrganizationSecurityPoliciesListAssociationsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::OrganizationSecurityPoliciesListAssociationsResponse'];

coerce 'OrganizationSecurityPoliciesListAssociationsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::OrganizationSecurityPoliciesListAssociationsResponse'->new($_) };

declare 'RepeatedOrganizationSecurityPoliciesListAssociationsResponse',
    as ArrayRef[OrganizationSecurityPoliciesListAssociationsResponse()];

coerce 'RepeatedOrganizationSecurityPoliciesListAssociationsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::OrganizationSecurityPoliciesListAssociationsResponse'->new($_) } @$_ ] };

declare 'MapStringOrganizationSecurityPoliciesListAssociationsResponse',
    as HashRef[OrganizationSecurityPoliciesListAssociationsResponse()];

declare 'OutlierDetection',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::OutlierDetection'];

coerce 'OutlierDetection',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::OutlierDetection'->new($_) };

declare 'RepeatedOutlierDetection',
    as ArrayRef[OutlierDetection()];

coerce 'RepeatedOutlierDetection',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::OutlierDetection'->new($_) } @$_ ] };

declare 'MapStringOutlierDetection',
    as HashRef[OutlierDetection()];

declare 'PacketIntervals',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketIntervals'];

coerce 'PacketIntervals',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketIntervals'->new($_) };

declare 'RepeatedPacketIntervals',
    as ArrayRef[PacketIntervals()];

coerce 'RepeatedPacketIntervals',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketIntervals'->new($_) } @$_ ] };

declare 'MapStringPacketIntervals',
    as HashRef[PacketIntervals()];

declare 'Duration',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'PacketMirroring',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroring'];

coerce 'PacketMirroring',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroring'->new($_) };

declare 'RepeatedPacketMirroring',
    as ArrayRef[PacketMirroring()];

coerce 'RepeatedPacketMirroring',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroring'->new($_) } @$_ ] };

declare 'MapStringPacketMirroring',
    as HashRef[PacketMirroring()];

declare 'Enable',
    as (Int | Str);

declare 'PacketMirroringAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringAggregatedList'];

coerce 'PacketMirroringAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringAggregatedList'->new($_) };

declare 'RepeatedPacketMirroringAggregatedList',
    as ArrayRef[PacketMirroringAggregatedList()];

coerce 'RepeatedPacketMirroringAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringAggregatedList'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringAggregatedList',
    as HashRef[PacketMirroringAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'PacketMirroringFilter',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringFilter'];

coerce 'PacketMirroringFilter',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringFilter'->new($_) };

declare 'RepeatedPacketMirroringFilter',
    as ArrayRef[PacketMirroringFilter()];

coerce 'RepeatedPacketMirroringFilter',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringFilter'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringFilter',
    as HashRef[PacketMirroringFilter()];

declare 'Direction',
    as (Int | Str);

declare 'PacketMirroringForwardingRuleInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringForwardingRuleInfo'];

coerce 'PacketMirroringForwardingRuleInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringForwardingRuleInfo'->new($_) };

declare 'RepeatedPacketMirroringForwardingRuleInfo',
    as ArrayRef[PacketMirroringForwardingRuleInfo()];

coerce 'RepeatedPacketMirroringForwardingRuleInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringForwardingRuleInfo'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringForwardingRuleInfo',
    as HashRef[PacketMirroringForwardingRuleInfo()];

declare 'PacketMirroringList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringList'];

coerce 'PacketMirroringList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringList'->new($_) };

declare 'RepeatedPacketMirroringList',
    as ArrayRef[PacketMirroringList()];

coerce 'RepeatedPacketMirroringList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringList'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringList',
    as HashRef[PacketMirroringList()];

declare 'PacketMirroringMirroredResourceInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfo'];

coerce 'PacketMirroringMirroredResourceInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfo'->new($_) };

declare 'RepeatedPacketMirroringMirroredResourceInfo',
    as ArrayRef[PacketMirroringMirroredResourceInfo()];

coerce 'RepeatedPacketMirroringMirroredResourceInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfo'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringMirroredResourceInfo',
    as HashRef[PacketMirroringMirroredResourceInfo()];

declare 'PacketMirroringMirroredResourceInfoInstanceInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfoInstanceInfo'];

coerce 'PacketMirroringMirroredResourceInfoInstanceInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfoInstanceInfo'->new($_) };

declare 'RepeatedPacketMirroringMirroredResourceInfoInstanceInfo',
    as ArrayRef[PacketMirroringMirroredResourceInfoInstanceInfo()];

coerce 'RepeatedPacketMirroringMirroredResourceInfoInstanceInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfoInstanceInfo'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringMirroredResourceInfoInstanceInfo',
    as HashRef[PacketMirroringMirroredResourceInfoInstanceInfo()];

declare 'PacketMirroringMirroredResourceInfoSubnetInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfoSubnetInfo'];

coerce 'PacketMirroringMirroredResourceInfoSubnetInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfoSubnetInfo'->new($_) };

declare 'RepeatedPacketMirroringMirroredResourceInfoSubnetInfo',
    as ArrayRef[PacketMirroringMirroredResourceInfoSubnetInfo()];

coerce 'RepeatedPacketMirroringMirroredResourceInfoSubnetInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringMirroredResourceInfoSubnetInfo'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringMirroredResourceInfoSubnetInfo',
    as HashRef[PacketMirroringMirroredResourceInfoSubnetInfo()];

declare 'PacketMirroringNetworkInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringNetworkInfo'];

coerce 'PacketMirroringNetworkInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringNetworkInfo'->new($_) };

declare 'RepeatedPacketMirroringNetworkInfo',
    as ArrayRef[PacketMirroringNetworkInfo()];

coerce 'RepeatedPacketMirroringNetworkInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringNetworkInfo'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringNetworkInfo',
    as HashRef[PacketMirroringNetworkInfo()];

declare 'PacketMirroringsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PacketMirroringsScopedList'];

coerce 'PacketMirroringsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PacketMirroringsScopedList'->new($_) };

declare 'RepeatedPacketMirroringsScopedList',
    as ArrayRef[PacketMirroringsScopedList()];

coerce 'RepeatedPacketMirroringsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PacketMirroringsScopedList'->new($_) } @$_ ] };

declare 'MapStringPacketMirroringsScopedList',
    as HashRef[PacketMirroringsScopedList()];

declare 'PatchAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchAutoscalerRequest'];

coerce 'PatchAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchAutoscalerRequest'->new($_) };

declare 'RepeatedPatchAutoscalerRequest',
    as ArrayRef[PatchAutoscalerRequest()];

coerce 'RepeatedPatchAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringPatchAutoscalerRequest',
    as HashRef[PatchAutoscalerRequest()];

declare 'PatchBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchBackendBucketRequest'];

coerce 'PatchBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchBackendBucketRequest'->new($_) };

declare 'RepeatedPatchBackendBucketRequest',
    as ArrayRef[PatchBackendBucketRequest()];

coerce 'RepeatedPatchBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringPatchBackendBucketRequest',
    as HashRef[PatchBackendBucketRequest()];

declare 'PatchBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchBackendServiceRequest'];

coerce 'PatchBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchBackendServiceRequest'->new($_) };

declare 'RepeatedPatchBackendServiceRequest',
    as ArrayRef[PatchBackendServiceRequest()];

coerce 'RepeatedPatchBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringPatchBackendServiceRequest',
    as HashRef[PatchBackendServiceRequest()];

declare 'PatchCrossSiteNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchCrossSiteNetworkRequest'];

coerce 'PatchCrossSiteNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchCrossSiteNetworkRequest'->new($_) };

declare 'RepeatedPatchCrossSiteNetworkRequest',
    as ArrayRef[PatchCrossSiteNetworkRequest()];

coerce 'RepeatedPatchCrossSiteNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchCrossSiteNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringPatchCrossSiteNetworkRequest',
    as HashRef[PatchCrossSiteNetworkRequest()];

declare 'PatchFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchFirewallPolicyRequest'];

coerce 'PatchFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchFirewallPolicyRequest'->new($_) };

declare 'RepeatedPatchFirewallPolicyRequest',
    as ArrayRef[PatchFirewallPolicyRequest()];

coerce 'RepeatedPatchFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchFirewallPolicyRequest',
    as HashRef[PatchFirewallPolicyRequest()];

declare 'PatchFirewallRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchFirewallRequest'];

coerce 'PatchFirewallRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchFirewallRequest'->new($_) };

declare 'RepeatedPatchFirewallRequest',
    as ArrayRef[PatchFirewallRequest()];

coerce 'RepeatedPatchFirewallRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchFirewallRequest'->new($_) } @$_ ] };

declare 'MapStringPatchFirewallRequest',
    as HashRef[PatchFirewallRequest()];

declare 'PatchForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchForwardingRuleRequest'];

coerce 'PatchForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchForwardingRuleRequest'->new($_) };

declare 'RepeatedPatchForwardingRuleRequest',
    as ArrayRef[PatchForwardingRuleRequest()];

coerce 'RepeatedPatchForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringPatchForwardingRuleRequest',
    as HashRef[PatchForwardingRuleRequest()];

declare 'PatchGlobalForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchGlobalForwardingRuleRequest'];

coerce 'PatchGlobalForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchGlobalForwardingRuleRequest'->new($_) };

declare 'RepeatedPatchGlobalForwardingRuleRequest',
    as ArrayRef[PatchGlobalForwardingRuleRequest()];

coerce 'RepeatedPatchGlobalForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchGlobalForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringPatchGlobalForwardingRuleRequest',
    as HashRef[PatchGlobalForwardingRuleRequest()];

declare 'PatchGlobalPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchGlobalPublicDelegatedPrefixeRequest'];

coerce 'PatchGlobalPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchGlobalPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedPatchGlobalPublicDelegatedPrefixeRequest',
    as ArrayRef[PatchGlobalPublicDelegatedPrefixeRequest()];

coerce 'RepeatedPatchGlobalPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchGlobalPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringPatchGlobalPublicDelegatedPrefixeRequest',
    as HashRef[PatchGlobalPublicDelegatedPrefixeRequest()];

declare 'PatchHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchHealthCheckRequest'];

coerce 'PatchHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchHealthCheckRequest'->new($_) };

declare 'RepeatedPatchHealthCheckRequest',
    as ArrayRef[PatchHealthCheckRequest()];

coerce 'RepeatedPatchHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringPatchHealthCheckRequest',
    as HashRef[PatchHealthCheckRequest()];

declare 'PatchImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchImageRequest'];

coerce 'PatchImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchImageRequest'->new($_) };

declare 'RepeatedPatchImageRequest',
    as ArrayRef[PatchImageRequest()];

coerce 'RepeatedPatchImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchImageRequest'->new($_) } @$_ ] };

declare 'MapStringPatchImageRequest',
    as HashRef[PatchImageRequest()];

declare 'PatchInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchInstanceGroupManagerRequest'];

coerce 'PatchInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedPatchInstanceGroupManagerRequest',
    as ArrayRef[PatchInstanceGroupManagerRequest()];

coerce 'RepeatedPatchInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringPatchInstanceGroupManagerRequest',
    as HashRef[PatchInstanceGroupManagerRequest()];

declare 'PatchInstanceSettingRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchInstanceSettingRequest'];

coerce 'PatchInstanceSettingRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchInstanceSettingRequest'->new($_) };

declare 'RepeatedPatchInstanceSettingRequest',
    as ArrayRef[PatchInstanceSettingRequest()];

coerce 'RepeatedPatchInstanceSettingRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchInstanceSettingRequest'->new($_) } @$_ ] };

declare 'MapStringPatchInstanceSettingRequest',
    as HashRef[PatchInstanceSettingRequest()];

declare 'PatchInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchInterconnectAttachmentGroupRequest'];

coerce 'PatchInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedPatchInterconnectAttachmentGroupRequest',
    as ArrayRef[PatchInterconnectAttachmentGroupRequest()];

coerce 'RepeatedPatchInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringPatchInterconnectAttachmentGroupRequest',
    as HashRef[PatchInterconnectAttachmentGroupRequest()];

declare 'PatchInterconnectAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchInterconnectAttachmentRequest'];

coerce 'PatchInterconnectAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectAttachmentRequest'->new($_) };

declare 'RepeatedPatchInterconnectAttachmentRequest',
    as ArrayRef[PatchInterconnectAttachmentRequest()];

coerce 'RepeatedPatchInterconnectAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringPatchInterconnectAttachmentRequest',
    as HashRef[PatchInterconnectAttachmentRequest()];

declare 'PatchInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchInterconnectGroupRequest'];

coerce 'PatchInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectGroupRequest'->new($_) };

declare 'RepeatedPatchInterconnectGroupRequest',
    as ArrayRef[PatchInterconnectGroupRequest()];

coerce 'RepeatedPatchInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringPatchInterconnectGroupRequest',
    as HashRef[PatchInterconnectGroupRequest()];

declare 'PatchInterconnectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchInterconnectRequest'];

coerce 'PatchInterconnectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectRequest'->new($_) };

declare 'RepeatedPatchInterconnectRequest',
    as ArrayRef[PatchInterconnectRequest()];

coerce 'RepeatedPatchInterconnectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchInterconnectRequest'->new($_) } @$_ ] };

declare 'MapStringPatchInterconnectRequest',
    as HashRef[PatchInterconnectRequest()];

declare 'PatchNamedSetRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchNamedSetRouterRequest'];

coerce 'PatchNamedSetRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchNamedSetRouterRequest'->new($_) };

declare 'RepeatedPatchNamedSetRouterRequest',
    as ArrayRef[PatchNamedSetRouterRequest()];

coerce 'RepeatedPatchNamedSetRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchNamedSetRouterRequest'->new($_) } @$_ ] };

declare 'MapStringPatchNamedSetRouterRequest',
    as HashRef[PatchNamedSetRouterRequest()];

declare 'PatchNetworkAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchNetworkAttachmentRequest'];

coerce 'PatchNetworkAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchNetworkAttachmentRequest'->new($_) };

declare 'RepeatedPatchNetworkAttachmentRequest',
    as ArrayRef[PatchNetworkAttachmentRequest()];

coerce 'RepeatedPatchNetworkAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchNetworkAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringPatchNetworkAttachmentRequest',
    as HashRef[PatchNetworkAttachmentRequest()];

declare 'PatchNetworkEdgeSecurityServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchNetworkEdgeSecurityServiceRequest'];

coerce 'PatchNetworkEdgeSecurityServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchNetworkEdgeSecurityServiceRequest'->new($_) };

declare 'RepeatedPatchNetworkEdgeSecurityServiceRequest',
    as ArrayRef[PatchNetworkEdgeSecurityServiceRequest()];

coerce 'RepeatedPatchNetworkEdgeSecurityServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchNetworkEdgeSecurityServiceRequest'->new($_) } @$_ ] };

declare 'MapStringPatchNetworkEdgeSecurityServiceRequest',
    as HashRef[PatchNetworkEdgeSecurityServiceRequest()];

declare 'PatchNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchNetworkFirewallPolicyRequest'];

coerce 'PatchNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedPatchNetworkFirewallPolicyRequest',
    as ArrayRef[PatchNetworkFirewallPolicyRequest()];

coerce 'RepeatedPatchNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchNetworkFirewallPolicyRequest',
    as HashRef[PatchNetworkFirewallPolicyRequest()];

declare 'PatchNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchNetworkRequest'];

coerce 'PatchNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchNetworkRequest'->new($_) };

declare 'RepeatedPatchNetworkRequest',
    as ArrayRef[PatchNetworkRequest()];

coerce 'RepeatedPatchNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringPatchNetworkRequest',
    as HashRef[PatchNetworkRequest()];

declare 'PatchNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchNodeGroupRequest'];

coerce 'PatchNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchNodeGroupRequest'->new($_) };

declare 'RepeatedPatchNodeGroupRequest',
    as ArrayRef[PatchNodeGroupRequest()];

coerce 'RepeatedPatchNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringPatchNodeGroupRequest',
    as HashRef[PatchNodeGroupRequest()];

declare 'PatchOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchOrganizationSecurityPolicyRequest'];

coerce 'PatchOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedPatchOrganizationSecurityPolicyRequest',
    as ArrayRef[PatchOrganizationSecurityPolicyRequest()];

coerce 'RepeatedPatchOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchOrganizationSecurityPolicyRequest',
    as HashRef[PatchOrganizationSecurityPolicyRequest()];

declare 'PatchPacketMirroringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchPacketMirroringRequest'];

coerce 'PatchPacketMirroringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchPacketMirroringRequest'->new($_) };

declare 'RepeatedPatchPacketMirroringRequest',
    as ArrayRef[PatchPacketMirroringRequest()];

coerce 'RepeatedPatchPacketMirroringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchPacketMirroringRequest'->new($_) } @$_ ] };

declare 'MapStringPatchPacketMirroringRequest',
    as HashRef[PatchPacketMirroringRequest()];

declare 'PatchPacketMirroringRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchPacketMirroringRuleNetworkFirewallPolicyRequest'];

coerce 'PatchPacketMirroringRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchPacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedPatchPacketMirroringRuleNetworkFirewallPolicyRequest',
    as ArrayRef[PatchPacketMirroringRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedPatchPacketMirroringRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchPacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchPacketMirroringRuleNetworkFirewallPolicyRequest',
    as HashRef[PatchPacketMirroringRuleNetworkFirewallPolicyRequest()];

declare 'PatchPerInstanceConfigsInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchPerInstanceConfigsInstanceGroupManagerRequest'];

coerce 'PatchPerInstanceConfigsInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchPerInstanceConfigsInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedPatchPerInstanceConfigsInstanceGroupManagerRequest',
    as ArrayRef[PatchPerInstanceConfigsInstanceGroupManagerRequest()];

coerce 'RepeatedPatchPerInstanceConfigsInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchPerInstanceConfigsInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringPatchPerInstanceConfigsInstanceGroupManagerRequest',
    as HashRef[PatchPerInstanceConfigsInstanceGroupManagerRequest()];

declare 'PatchPerInstanceConfigsRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchPerInstanceConfigsRegionInstanceGroupManagerRequest'];

coerce 'PatchPerInstanceConfigsRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchPerInstanceConfigsRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedPatchPerInstanceConfigsRegionInstanceGroupManagerRequest',
    as ArrayRef[PatchPerInstanceConfigsRegionInstanceGroupManagerRequest()];

coerce 'RepeatedPatchPerInstanceConfigsRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchPerInstanceConfigsRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringPatchPerInstanceConfigsRegionInstanceGroupManagerRequest',
    as HashRef[PatchPerInstanceConfigsRegionInstanceGroupManagerRequest()];

declare 'PatchPublicAdvertisedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchPublicAdvertisedPrefixeRequest'];

coerce 'PatchPublicAdvertisedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchPublicAdvertisedPrefixeRequest'->new($_) };

declare 'RepeatedPatchPublicAdvertisedPrefixeRequest',
    as ArrayRef[PatchPublicAdvertisedPrefixeRequest()];

coerce 'RepeatedPatchPublicAdvertisedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchPublicAdvertisedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringPatchPublicAdvertisedPrefixeRequest',
    as HashRef[PatchPublicAdvertisedPrefixeRequest()];

declare 'PatchPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchPublicDelegatedPrefixeRequest'];

coerce 'PatchPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedPatchPublicDelegatedPrefixeRequest',
    as ArrayRef[PatchPublicDelegatedPrefixeRequest()];

coerce 'RepeatedPatchPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringPatchPublicDelegatedPrefixeRequest',
    as HashRef[PatchPublicDelegatedPrefixeRequest()];

declare 'PatchRegionAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionAutoscalerRequest'];

coerce 'PatchRegionAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionAutoscalerRequest'->new($_) };

declare 'RepeatedPatchRegionAutoscalerRequest',
    as ArrayRef[PatchRegionAutoscalerRequest()];

coerce 'RepeatedPatchRegionAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionAutoscalerRequest',
    as HashRef[PatchRegionAutoscalerRequest()];

declare 'PatchRegionBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionBackendBucketRequest'];

coerce 'PatchRegionBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionBackendBucketRequest'->new($_) };

declare 'RepeatedPatchRegionBackendBucketRequest',
    as ArrayRef[PatchRegionBackendBucketRequest()];

coerce 'RepeatedPatchRegionBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionBackendBucketRequest',
    as HashRef[PatchRegionBackendBucketRequest()];

declare 'PatchRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionBackendServiceRequest'];

coerce 'PatchRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionBackendServiceRequest'->new($_) };

declare 'RepeatedPatchRegionBackendServiceRequest',
    as ArrayRef[PatchRegionBackendServiceRequest()];

coerce 'RepeatedPatchRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionBackendServiceRequest',
    as HashRef[PatchRegionBackendServiceRequest()];

declare 'PatchRegionCompositeHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionCompositeHealthCheckRequest'];

coerce 'PatchRegionCompositeHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionCompositeHealthCheckRequest'->new($_) };

declare 'RepeatedPatchRegionCompositeHealthCheckRequest',
    as ArrayRef[PatchRegionCompositeHealthCheckRequest()];

coerce 'RepeatedPatchRegionCompositeHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionCompositeHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionCompositeHealthCheckRequest',
    as HashRef[PatchRegionCompositeHealthCheckRequest()];

declare 'PatchRegionHealthAggregationPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionHealthAggregationPolicyRequest'];

coerce 'PatchRegionHealthAggregationPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthAggregationPolicyRequest'->new($_) };

declare 'RepeatedPatchRegionHealthAggregationPolicyRequest',
    as ArrayRef[PatchRegionHealthAggregationPolicyRequest()];

coerce 'RepeatedPatchRegionHealthAggregationPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthAggregationPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionHealthAggregationPolicyRequest',
    as HashRef[PatchRegionHealthAggregationPolicyRequest()];

declare 'PatchRegionHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionHealthCheckRequest'];

coerce 'PatchRegionHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthCheckRequest'->new($_) };

declare 'RepeatedPatchRegionHealthCheckRequest',
    as ArrayRef[PatchRegionHealthCheckRequest()];

coerce 'RepeatedPatchRegionHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionHealthCheckRequest',
    as HashRef[PatchRegionHealthCheckRequest()];

declare 'PatchRegionHealthCheckServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionHealthCheckServiceRequest'];

coerce 'PatchRegionHealthCheckServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthCheckServiceRequest'->new($_) };

declare 'RepeatedPatchRegionHealthCheckServiceRequest',
    as ArrayRef[PatchRegionHealthCheckServiceRequest()];

coerce 'RepeatedPatchRegionHealthCheckServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthCheckServiceRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionHealthCheckServiceRequest',
    as HashRef[PatchRegionHealthCheckServiceRequest()];

declare 'PatchRegionHealthSourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionHealthSourceRequest'];

coerce 'PatchRegionHealthSourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthSourceRequest'->new($_) };

declare 'RepeatedPatchRegionHealthSourceRequest',
    as ArrayRef[PatchRegionHealthSourceRequest()];

coerce 'RepeatedPatchRegionHealthSourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionHealthSourceRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionHealthSourceRequest',
    as HashRef[PatchRegionHealthSourceRequest()];

declare 'PatchRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionInstanceGroupManagerRequest'];

coerce 'PatchRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedPatchRegionInstanceGroupManagerRequest',
    as ArrayRef[PatchRegionInstanceGroupManagerRequest()];

coerce 'RepeatedPatchRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionInstanceGroupManagerRequest',
    as HashRef[PatchRegionInstanceGroupManagerRequest()];

declare 'PatchRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionNetworkFirewallPolicyRequest'];

coerce 'PatchRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedPatchRegionNetworkFirewallPolicyRequest',
    as ArrayRef[PatchRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedPatchRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionNetworkFirewallPolicyRequest',
    as HashRef[PatchRegionNetworkFirewallPolicyRequest()];

declare 'PatchRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionSecurityPolicyRequest'];

coerce 'PatchRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedPatchRegionSecurityPolicyRequest',
    as ArrayRef[PatchRegionSecurityPolicyRequest()];

coerce 'RepeatedPatchRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionSecurityPolicyRequest',
    as HashRef[PatchRegionSecurityPolicyRequest()];

declare 'PatchRegionSnapshotSettingRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionSnapshotSettingRequest'];

coerce 'PatchRegionSnapshotSettingRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionSnapshotSettingRequest'->new($_) };

declare 'RepeatedPatchRegionSnapshotSettingRequest',
    as ArrayRef[PatchRegionSnapshotSettingRequest()];

coerce 'RepeatedPatchRegionSnapshotSettingRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionSnapshotSettingRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionSnapshotSettingRequest',
    as HashRef[PatchRegionSnapshotSettingRequest()];

declare 'PatchRegionSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionSslPolicyRequest'];

coerce 'PatchRegionSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionSslPolicyRequest'->new($_) };

declare 'RepeatedPatchRegionSslPolicyRequest',
    as ArrayRef[PatchRegionSslPolicyRequest()];

coerce 'RepeatedPatchRegionSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionSslPolicyRequest',
    as HashRef[PatchRegionSslPolicyRequest()];

declare 'PatchRegionTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionTargetHttpsProxyRequest'];

coerce 'PatchRegionTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedPatchRegionTargetHttpsProxyRequest',
    as ArrayRef[PatchRegionTargetHttpsProxyRequest()];

coerce 'RepeatedPatchRegionTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionTargetHttpsProxyRequest',
    as HashRef[PatchRegionTargetHttpsProxyRequest()];

declare 'PatchRegionUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRegionUrlMapRequest'];

coerce 'PatchRegionUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRegionUrlMapRequest'->new($_) };

declare 'RepeatedPatchRegionUrlMapRequest',
    as ArrayRef[PatchRegionUrlMapRequest()];

coerce 'RepeatedPatchRegionUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRegionUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRegionUrlMapRequest',
    as HashRef[PatchRegionUrlMapRequest()];

declare 'PatchResourcePolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchResourcePolicyRequest'];

coerce 'PatchResourcePolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchResourcePolicyRequest'->new($_) };

declare 'RepeatedPatchResourcePolicyRequest',
    as ArrayRef[PatchResourcePolicyRequest()];

coerce 'RepeatedPatchResourcePolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchResourcePolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchResourcePolicyRequest',
    as HashRef[PatchResourcePolicyRequest()];

declare 'PatchRoutePolicyRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRoutePolicyRouterRequest'];

coerce 'PatchRoutePolicyRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRoutePolicyRouterRequest'->new($_) };

declare 'RepeatedPatchRoutePolicyRouterRequest',
    as ArrayRef[PatchRoutePolicyRouterRequest()];

coerce 'RepeatedPatchRoutePolicyRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRoutePolicyRouterRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRoutePolicyRouterRequest',
    as HashRef[PatchRoutePolicyRouterRequest()];

declare 'PatchRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRouterRequest'];

coerce 'PatchRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRouterRequest'->new($_) };

declare 'RepeatedPatchRouterRequest',
    as ArrayRef[PatchRouterRequest()];

coerce 'RepeatedPatchRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRouterRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRouterRequest',
    as HashRef[PatchRouterRequest()];

declare 'PatchRuleFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRuleFirewallPolicyRequest'];

coerce 'PatchRuleFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRuleFirewallPolicyRequest'->new($_) };

declare 'RepeatedPatchRuleFirewallPolicyRequest',
    as ArrayRef[PatchRuleFirewallPolicyRequest()];

coerce 'RepeatedPatchRuleFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRuleFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRuleFirewallPolicyRequest',
    as HashRef[PatchRuleFirewallPolicyRequest()];

declare 'PatchRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRuleNetworkFirewallPolicyRequest'];

coerce 'PatchRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedPatchRuleNetworkFirewallPolicyRequest',
    as ArrayRef[PatchRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedPatchRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRuleNetworkFirewallPolicyRequest',
    as HashRef[PatchRuleNetworkFirewallPolicyRequest()];

declare 'PatchRuleOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRuleOrganizationSecurityPolicyRequest'];

coerce 'PatchRuleOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRuleOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedPatchRuleOrganizationSecurityPolicyRequest',
    as ArrayRef[PatchRuleOrganizationSecurityPolicyRequest()];

coerce 'RepeatedPatchRuleOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRuleOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRuleOrganizationSecurityPolicyRequest',
    as HashRef[PatchRuleOrganizationSecurityPolicyRequest()];

declare 'PatchRuleRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRuleRegionNetworkFirewallPolicyRequest'];

coerce 'PatchRuleRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRuleRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedPatchRuleRegionNetworkFirewallPolicyRequest',
    as ArrayRef[PatchRuleRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedPatchRuleRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRuleRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRuleRegionNetworkFirewallPolicyRequest',
    as HashRef[PatchRuleRegionNetworkFirewallPolicyRequest()];

declare 'PatchRuleRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRuleRegionSecurityPolicyRequest'];

coerce 'PatchRuleRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRuleRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedPatchRuleRegionSecurityPolicyRequest',
    as ArrayRef[PatchRuleRegionSecurityPolicyRequest()];

coerce 'RepeatedPatchRuleRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRuleRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRuleRegionSecurityPolicyRequest',
    as HashRef[PatchRuleRegionSecurityPolicyRequest()];

declare 'PatchRuleSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchRuleSecurityPolicyRequest'];

coerce 'PatchRuleSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchRuleSecurityPolicyRequest'->new($_) };

declare 'RepeatedPatchRuleSecurityPolicyRequest',
    as ArrayRef[PatchRuleSecurityPolicyRequest()];

coerce 'RepeatedPatchRuleSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchRuleSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchRuleSecurityPolicyRequest',
    as HashRef[PatchRuleSecurityPolicyRequest()];

declare 'PatchSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchSecurityPolicyRequest'];

coerce 'PatchSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchSecurityPolicyRequest'->new($_) };

declare 'RepeatedPatchSecurityPolicyRequest',
    as ArrayRef[PatchSecurityPolicyRequest()];

coerce 'RepeatedPatchSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchSecurityPolicyRequest',
    as HashRef[PatchSecurityPolicyRequest()];

declare 'PatchServiceAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchServiceAttachmentRequest'];

coerce 'PatchServiceAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchServiceAttachmentRequest'->new($_) };

declare 'RepeatedPatchServiceAttachmentRequest',
    as ArrayRef[PatchServiceAttachmentRequest()];

coerce 'RepeatedPatchServiceAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchServiceAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringPatchServiceAttachmentRequest',
    as HashRef[PatchServiceAttachmentRequest()];

declare 'PatchSnapshotSettingRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchSnapshotSettingRequest'];

coerce 'PatchSnapshotSettingRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchSnapshotSettingRequest'->new($_) };

declare 'RepeatedPatchSnapshotSettingRequest',
    as ArrayRef[PatchSnapshotSettingRequest()];

coerce 'RepeatedPatchSnapshotSettingRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchSnapshotSettingRequest'->new($_) } @$_ ] };

declare 'MapStringPatchSnapshotSettingRequest',
    as HashRef[PatchSnapshotSettingRequest()];

declare 'PatchSslPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchSslPolicyRequest'];

coerce 'PatchSslPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchSslPolicyRequest'->new($_) };

declare 'RepeatedPatchSslPolicyRequest',
    as ArrayRef[PatchSslPolicyRequest()];

coerce 'RepeatedPatchSslPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchSslPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchSslPolicyRequest',
    as HashRef[PatchSslPolicyRequest()];

declare 'PatchSubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchSubnetworkRequest'];

coerce 'PatchSubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchSubnetworkRequest'->new($_) };

declare 'RepeatedPatchSubnetworkRequest',
    as ArrayRef[PatchSubnetworkRequest()];

coerce 'RepeatedPatchSubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchSubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringPatchSubnetworkRequest',
    as HashRef[PatchSubnetworkRequest()];

declare 'PatchTargetGrpcProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchTargetGrpcProxyRequest'];

coerce 'PatchTargetGrpcProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchTargetGrpcProxyRequest'->new($_) };

declare 'RepeatedPatchTargetGrpcProxyRequest',
    as ArrayRef[PatchTargetGrpcProxyRequest()];

coerce 'RepeatedPatchTargetGrpcProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchTargetGrpcProxyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchTargetGrpcProxyRequest',
    as HashRef[PatchTargetGrpcProxyRequest()];

declare 'PatchTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchTargetHttpProxyRequest'];

coerce 'PatchTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchTargetHttpProxyRequest'->new($_) };

declare 'RepeatedPatchTargetHttpProxyRequest',
    as ArrayRef[PatchTargetHttpProxyRequest()];

coerce 'RepeatedPatchTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchTargetHttpProxyRequest',
    as HashRef[PatchTargetHttpProxyRequest()];

declare 'PatchTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchTargetHttpsProxyRequest'];

coerce 'PatchTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedPatchTargetHttpsProxyRequest',
    as ArrayRef[PatchTargetHttpsProxyRequest()];

coerce 'RepeatedPatchTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringPatchTargetHttpsProxyRequest',
    as HashRef[PatchTargetHttpsProxyRequest()];

declare 'PatchUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchUrlMapRequest'];

coerce 'PatchUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchUrlMapRequest'->new($_) };

declare 'RepeatedPatchUrlMapRequest',
    as ArrayRef[PatchUrlMapRequest()];

coerce 'RepeatedPatchUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringPatchUrlMapRequest',
    as HashRef[PatchUrlMapRequest()];

declare 'PatchWireGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PatchWireGroupRequest'];

coerce 'PatchWireGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PatchWireGroupRequest'->new($_) };

declare 'RepeatedPatchWireGroupRequest',
    as ArrayRef[PatchWireGroupRequest()];

coerce 'RepeatedPatchWireGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PatchWireGroupRequest'->new($_) } @$_ ] };

declare 'MapStringPatchWireGroupRequest',
    as HashRef[PatchWireGroupRequest()];

declare 'PathMatcher',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PathMatcher'];

coerce 'PathMatcher',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PathMatcher'->new($_) };

declare 'RepeatedPathMatcher',
    as ArrayRef[PathMatcher()];

coerce 'RepeatedPathMatcher',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PathMatcher'->new($_) } @$_ ] };

declare 'MapStringPathMatcher',
    as HashRef[PathMatcher()];

declare 'PathRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PathRule'];

coerce 'PathRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PathRule'->new($_) };

declare 'RepeatedPathRule',
    as ArrayRef[PathRule()];

coerce 'RepeatedPathRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PathRule'->new($_) } @$_ ] };

declare 'MapStringPathRule',
    as HashRef[PathRule()];

declare 'PauseRolloutRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PauseRolloutRequest'];

coerce 'PauseRolloutRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PauseRolloutRequest'->new($_) };

declare 'RepeatedPauseRolloutRequest',
    as ArrayRef[PauseRolloutRequest()];

coerce 'RepeatedPauseRolloutRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PauseRolloutRequest'->new($_) } @$_ ] };

declare 'MapStringPauseRolloutRequest',
    as HashRef[PauseRolloutRequest()];

declare 'PerInstanceConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PerInstanceConfig'];

coerce 'PerInstanceConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PerInstanceConfig'->new($_) };

declare 'RepeatedPerInstanceConfig',
    as ArrayRef[PerInstanceConfig()];

coerce 'RepeatedPerInstanceConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PerInstanceConfig'->new($_) } @$_ ] };

declare 'MapStringPerInstanceConfig',
    as HashRef[PerInstanceConfig()];

declare 'Status',
    as (Int | Str);

declare 'PerformMaintenanceInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PerformMaintenanceInstanceRequest'];

coerce 'PerformMaintenanceInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceInstanceRequest'->new($_) };

declare 'RepeatedPerformMaintenanceInstanceRequest',
    as ArrayRef[PerformMaintenanceInstanceRequest()];

coerce 'RepeatedPerformMaintenanceInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringPerformMaintenanceInstanceRequest',
    as HashRef[PerformMaintenanceInstanceRequest()];

declare 'PerformMaintenanceNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PerformMaintenanceNodeGroupRequest'];

coerce 'PerformMaintenanceNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceNodeGroupRequest'->new($_) };

declare 'RepeatedPerformMaintenanceNodeGroupRequest',
    as ArrayRef[PerformMaintenanceNodeGroupRequest()];

coerce 'RepeatedPerformMaintenanceNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringPerformMaintenanceNodeGroupRequest',
    as HashRef[PerformMaintenanceNodeGroupRequest()];

declare 'PerformMaintenanceReservationBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationBlockRequest'];

coerce 'PerformMaintenanceReservationBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationBlockRequest'->new($_) };

declare 'RepeatedPerformMaintenanceReservationBlockRequest',
    as ArrayRef[PerformMaintenanceReservationBlockRequest()];

coerce 'RepeatedPerformMaintenanceReservationBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationBlockRequest'->new($_) } @$_ ] };

declare 'MapStringPerformMaintenanceReservationBlockRequest',
    as HashRef[PerformMaintenanceReservationBlockRequest()];

declare 'PerformMaintenanceReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationRequest'];

coerce 'PerformMaintenanceReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationRequest'->new($_) };

declare 'RepeatedPerformMaintenanceReservationRequest',
    as ArrayRef[PerformMaintenanceReservationRequest()];

coerce 'RepeatedPerformMaintenanceReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationRequest'->new($_) } @$_ ] };

declare 'MapStringPerformMaintenanceReservationRequest',
    as HashRef[PerformMaintenanceReservationRequest()];

declare 'PerformMaintenanceReservationSubBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationSubBlockRequest'];

coerce 'PerformMaintenanceReservationSubBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationSubBlockRequest'->new($_) };

declare 'RepeatedPerformMaintenanceReservationSubBlockRequest',
    as ArrayRef[PerformMaintenanceReservationSubBlockRequest()];

coerce 'RepeatedPerformMaintenanceReservationSubBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PerformMaintenanceReservationSubBlockRequest'->new($_) } @$_ ] };

declare 'MapStringPerformMaintenanceReservationSubBlockRequest',
    as HashRef[PerformMaintenanceReservationSubBlockRequest()];

declare 'PeriodicPartialMaintenanceSchedule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PeriodicPartialMaintenanceSchedule'];

coerce 'PeriodicPartialMaintenanceSchedule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PeriodicPartialMaintenanceSchedule'->new($_) };

declare 'RepeatedPeriodicPartialMaintenanceSchedule',
    as ArrayRef[PeriodicPartialMaintenanceSchedule()];

coerce 'RepeatedPeriodicPartialMaintenanceSchedule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PeriodicPartialMaintenanceSchedule'->new($_) } @$_ ] };

declare 'MapStringPeriodicPartialMaintenanceSchedule',
    as HashRef[PeriodicPartialMaintenanceSchedule()];

declare 'SubType',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'Policy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Policy'];

coerce 'Policy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Policy'->new($_) };

declare 'RepeatedPolicy',
    as ArrayRef[Policy()];

coerce 'RepeatedPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Policy'->new($_) } @$_ ] };

declare 'MapStringPolicy',
    as HashRef[Policy()];

declare 'PreconfiguredWafSet',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreconfiguredWafSet'];

coerce 'PreconfiguredWafSet',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreconfiguredWafSet'->new($_) };

declare 'RepeatedPreconfiguredWafSet',
    as ArrayRef[PreconfiguredWafSet()];

coerce 'RepeatedPreconfiguredWafSet',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreconfiguredWafSet'->new($_) } @$_ ] };

declare 'MapStringPreconfiguredWafSet',
    as HashRef[PreconfiguredWafSet()];

declare 'PreservedState',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedState'];

coerce 'PreservedState',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedState'->new($_) };

declare 'RepeatedPreservedState',
    as ArrayRef[PreservedState()];

coerce 'RepeatedPreservedState',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedState'->new($_) } @$_ ] };

declare 'MapStringPreservedState',
    as HashRef[PreservedState()];

declare 'DisksEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedState::DisksEntry'];

coerce 'DisksEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedState::DisksEntry'->new($_) };

declare 'RepeatedDisksEntry',
    as ArrayRef[DisksEntry()];

coerce 'RepeatedDisksEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedState::DisksEntry'->new($_) } @$_ ] };

declare 'MapStringDisksEntry',
    as HashRef[DisksEntry()];

declare 'ExternalIPsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedState::ExternalIPsEntry'];

coerce 'ExternalIPsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedState::ExternalIPsEntry'->new($_) };

declare 'RepeatedExternalIPsEntry',
    as ArrayRef[ExternalIPsEntry()];

coerce 'RepeatedExternalIPsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedState::ExternalIPsEntry'->new($_) } @$_ ] };

declare 'MapStringExternalIPsEntry',
    as HashRef[ExternalIPsEntry()];

declare 'InternalIPsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedState::InternalIPsEntry'];

coerce 'InternalIPsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedState::InternalIPsEntry'->new($_) };

declare 'RepeatedInternalIPsEntry',
    as ArrayRef[InternalIPsEntry()];

coerce 'RepeatedInternalIPsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedState::InternalIPsEntry'->new($_) } @$_ ] };

declare 'MapStringInternalIPsEntry',
    as HashRef[InternalIPsEntry()];

declare 'MetadataEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedState::MetadataEntry'];

coerce 'MetadataEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedState::MetadataEntry'->new($_) };

declare 'RepeatedMetadataEntry',
    as ArrayRef[MetadataEntry()];

coerce 'RepeatedMetadataEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedState::MetadataEntry'->new($_) } @$_ ] };

declare 'MapStringMetadataEntry',
    as HashRef[MetadataEntry()];

declare 'PreservedStatePreservedDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedStatePreservedDisk'];

coerce 'PreservedStatePreservedDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedStatePreservedDisk'->new($_) };

declare 'RepeatedPreservedStatePreservedDisk',
    as ArrayRef[PreservedStatePreservedDisk()];

coerce 'RepeatedPreservedStatePreservedDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedStatePreservedDisk'->new($_) } @$_ ] };

declare 'MapStringPreservedStatePreservedDisk',
    as HashRef[PreservedStatePreservedDisk()];

declare 'AutoDelete',
    as (Int | Str);

declare 'Mode',
    as (Int | Str);

declare 'PreservedStatePreservedNetworkIp',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedStatePreservedNetworkIp'];

coerce 'PreservedStatePreservedNetworkIp',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedStatePreservedNetworkIp'->new($_) };

declare 'RepeatedPreservedStatePreservedNetworkIp',
    as ArrayRef[PreservedStatePreservedNetworkIp()];

coerce 'RepeatedPreservedStatePreservedNetworkIp',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedStatePreservedNetworkIp'->new($_) } @$_ ] };

declare 'MapStringPreservedStatePreservedNetworkIp',
    as HashRef[PreservedStatePreservedNetworkIp()];

declare 'AutoDelete',
    as (Int | Str);

declare 'PreservedStatePreservedNetworkIpIpAddress',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreservedStatePreservedNetworkIpIpAddress'];

coerce 'PreservedStatePreservedNetworkIpIpAddress',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreservedStatePreservedNetworkIpIpAddress'->new($_) };

declare 'RepeatedPreservedStatePreservedNetworkIpIpAddress',
    as ArrayRef[PreservedStatePreservedNetworkIpIpAddress()];

coerce 'RepeatedPreservedStatePreservedNetworkIpIpAddress',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreservedStatePreservedNetworkIpIpAddress'->new($_) } @$_ ] };

declare 'MapStringPreservedStatePreservedNetworkIpIpAddress',
    as HashRef[PreservedStatePreservedNetworkIpIpAddress()];

declare 'PreviewFeature',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreviewFeature'];

coerce 'PreviewFeature',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreviewFeature'->new($_) };

declare 'RepeatedPreviewFeature',
    as ArrayRef[PreviewFeature()];

coerce 'RepeatedPreviewFeature',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreviewFeature'->new($_) } @$_ ] };

declare 'MapStringPreviewFeature',
    as HashRef[PreviewFeature()];

declare 'ActivationStatus',
    as (Int | Str);

declare 'PreviewFeatureList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreviewFeatureList'];

coerce 'PreviewFeatureList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureList'->new($_) };

declare 'RepeatedPreviewFeatureList',
    as ArrayRef[PreviewFeatureList()];

coerce 'RepeatedPreviewFeatureList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureList'->new($_) } @$_ ] };

declare 'MapStringPreviewFeatureList',
    as HashRef[PreviewFeatureList()];

declare 'PreviewFeatureRolloutOperation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreviewFeatureRolloutOperation'];

coerce 'PreviewFeatureRolloutOperation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureRolloutOperation'->new($_) };

declare 'RepeatedPreviewFeatureRolloutOperation',
    as ArrayRef[PreviewFeatureRolloutOperation()];

coerce 'RepeatedPreviewFeatureRolloutOperation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureRolloutOperation'->new($_) } @$_ ] };

declare 'MapStringPreviewFeatureRolloutOperation',
    as HashRef[PreviewFeatureRolloutOperation()];

declare 'PreviewFeatureRolloutOperationRolloutInput',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreviewFeatureRolloutOperationRolloutInput'];

coerce 'PreviewFeatureRolloutOperationRolloutInput',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureRolloutOperationRolloutInput'->new($_) };

declare 'RepeatedPreviewFeatureRolloutOperationRolloutInput',
    as ArrayRef[PreviewFeatureRolloutOperationRolloutInput()];

coerce 'RepeatedPreviewFeatureRolloutOperationRolloutInput',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureRolloutOperationRolloutInput'->new($_) } @$_ ] };

declare 'MapStringPreviewFeatureRolloutOperationRolloutInput',
    as HashRef[PreviewFeatureRolloutOperationRolloutInput()];

declare 'PredefinedRolloutPlan',
    as (Int | Str);

declare 'PreviewFeatureStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreviewFeatureStatus'];

coerce 'PreviewFeatureStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureStatus'->new($_) };

declare 'RepeatedPreviewFeatureStatus',
    as ArrayRef[PreviewFeatureStatus()];

coerce 'RepeatedPreviewFeatureStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureStatus'->new($_) } @$_ ] };

declare 'MapStringPreviewFeatureStatus',
    as HashRef[PreviewFeatureStatus()];

declare 'PreviewFeatureStatusReleaseStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreviewFeatureStatusReleaseStatus'];

coerce 'PreviewFeatureStatusReleaseStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureStatusReleaseStatus'->new($_) };

declare 'RepeatedPreviewFeatureStatusReleaseStatus',
    as ArrayRef[PreviewFeatureStatusReleaseStatus()];

coerce 'RepeatedPreviewFeatureStatusReleaseStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreviewFeatureStatusReleaseStatus'->new($_) } @$_ ] };

declare 'MapStringPreviewFeatureStatusReleaseStatus',
    as HashRef[PreviewFeatureStatusReleaseStatus()];

declare 'Stage',
    as (Int | Str);

declare 'PreviewRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PreviewRouterRequest'];

coerce 'PreviewRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PreviewRouterRequest'->new($_) };

declare 'RepeatedPreviewRouterRequest',
    as ArrayRef[PreviewRouterRequest()];

coerce 'RepeatedPreviewRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PreviewRouterRequest'->new($_) } @$_ ] };

declare 'MapStringPreviewRouterRequest',
    as HashRef[PreviewRouterRequest()];

declare 'Project',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Project'];

coerce 'Project',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Project'->new($_) };

declare 'RepeatedProject',
    as ArrayRef[Project()];

coerce 'RepeatedProject',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Project'->new($_) } @$_ ] };

declare 'MapStringProject',
    as HashRef[Project()];

declare 'CloudArmorTier',
    as (Int | Str);

declare 'DefaultNetworkTier',
    as (Int | Str);

declare 'VmDnsSetting',
    as (Int | Str);

declare 'XpnProjectStatus',
    as (Int | Str);

declare 'ProjectsDisableXpnResourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ProjectsDisableXpnResourceRequest'];

coerce 'ProjectsDisableXpnResourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ProjectsDisableXpnResourceRequest'->new($_) };

declare 'RepeatedProjectsDisableXpnResourceRequest',
    as ArrayRef[ProjectsDisableXpnResourceRequest()];

coerce 'RepeatedProjectsDisableXpnResourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ProjectsDisableXpnResourceRequest'->new($_) } @$_ ] };

declare 'MapStringProjectsDisableXpnResourceRequest',
    as HashRef[ProjectsDisableXpnResourceRequest()];

declare 'ProjectsEnableXpnResourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ProjectsEnableXpnResourceRequest'];

coerce 'ProjectsEnableXpnResourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ProjectsEnableXpnResourceRequest'->new($_) };

declare 'RepeatedProjectsEnableXpnResourceRequest',
    as ArrayRef[ProjectsEnableXpnResourceRequest()];

coerce 'RepeatedProjectsEnableXpnResourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ProjectsEnableXpnResourceRequest'->new($_) } @$_ ] };

declare 'MapStringProjectsEnableXpnResourceRequest',
    as HashRef[ProjectsEnableXpnResourceRequest()];

declare 'ProjectsGetXpnResources',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ProjectsGetXpnResources'];

coerce 'ProjectsGetXpnResources',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ProjectsGetXpnResources'->new($_) };

declare 'RepeatedProjectsGetXpnResources',
    as ArrayRef[ProjectsGetXpnResources()];

coerce 'RepeatedProjectsGetXpnResources',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ProjectsGetXpnResources'->new($_) } @$_ ] };

declare 'MapStringProjectsGetXpnResources',
    as HashRef[ProjectsGetXpnResources()];

declare 'ProjectsListXpnHostsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ProjectsListXpnHostsRequest'];

coerce 'ProjectsListXpnHostsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ProjectsListXpnHostsRequest'->new($_) };

declare 'RepeatedProjectsListXpnHostsRequest',
    as ArrayRef[ProjectsListXpnHostsRequest()];

coerce 'RepeatedProjectsListXpnHostsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ProjectsListXpnHostsRequest'->new($_) } @$_ ] };

declare 'MapStringProjectsListXpnHostsRequest',
    as HashRef[ProjectsListXpnHostsRequest()];

declare 'ProjectsSetCloudArmorTierRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ProjectsSetCloudArmorTierRequest'];

coerce 'ProjectsSetCloudArmorTierRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ProjectsSetCloudArmorTierRequest'->new($_) };

declare 'RepeatedProjectsSetCloudArmorTierRequest',
    as ArrayRef[ProjectsSetCloudArmorTierRequest()];

coerce 'RepeatedProjectsSetCloudArmorTierRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ProjectsSetCloudArmorTierRequest'->new($_) } @$_ ] };

declare 'MapStringProjectsSetCloudArmorTierRequest',
    as HashRef[ProjectsSetCloudArmorTierRequest()];

declare 'CloudArmorTier',
    as (Int | Str);

declare 'ProjectsSetDefaultNetworkTierRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ProjectsSetDefaultNetworkTierRequest'];

coerce 'ProjectsSetDefaultNetworkTierRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ProjectsSetDefaultNetworkTierRequest'->new($_) };

declare 'RepeatedProjectsSetDefaultNetworkTierRequest',
    as ArrayRef[ProjectsSetDefaultNetworkTierRequest()];

coerce 'RepeatedProjectsSetDefaultNetworkTierRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ProjectsSetDefaultNetworkTierRequest'->new($_) } @$_ ] };

declare 'MapStringProjectsSetDefaultNetworkTierRequest',
    as HashRef[ProjectsSetDefaultNetworkTierRequest()];

declare 'NetworkTier',
    as (Int | Str);

declare 'PublicAdvertisedPrefix',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefix'];

coerce 'PublicAdvertisedPrefix',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefix'->new($_) };

declare 'RepeatedPublicAdvertisedPrefix',
    as ArrayRef[PublicAdvertisedPrefix()];

coerce 'RepeatedPublicAdvertisedPrefix',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefix'->new($_) } @$_ ] };

declare 'MapStringPublicAdvertisedPrefix',
    as HashRef[PublicAdvertisedPrefix()];

declare 'ByoipApiVersion',
    as (Int | Str);

declare 'Ipv6AccessType',
    as (Int | Str);

declare 'PdpScope',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'PublicAdvertisedPrefixList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefixList'];

coerce 'PublicAdvertisedPrefixList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefixList'->new($_) };

declare 'RepeatedPublicAdvertisedPrefixList',
    as ArrayRef[PublicAdvertisedPrefixList()];

coerce 'RepeatedPublicAdvertisedPrefixList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefixList'->new($_) } @$_ ] };

declare 'MapStringPublicAdvertisedPrefixList',
    as HashRef[PublicAdvertisedPrefixList()];

declare 'PublicAdvertisedPrefixPublicDelegatedPrefix',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefixPublicDelegatedPrefix'];

coerce 'PublicAdvertisedPrefixPublicDelegatedPrefix',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefixPublicDelegatedPrefix'->new($_) };

declare 'RepeatedPublicAdvertisedPrefixPublicDelegatedPrefix',
    as ArrayRef[PublicAdvertisedPrefixPublicDelegatedPrefix()];

coerce 'RepeatedPublicAdvertisedPrefixPublicDelegatedPrefix',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicAdvertisedPrefixPublicDelegatedPrefix'->new($_) } @$_ ] };

declare 'MapStringPublicAdvertisedPrefixPublicDelegatedPrefix',
    as HashRef[PublicAdvertisedPrefixPublicDelegatedPrefix()];

declare 'PublicDelegatedPrefix',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefix'];

coerce 'PublicDelegatedPrefix',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefix'->new($_) };

declare 'RepeatedPublicDelegatedPrefix',
    as ArrayRef[PublicDelegatedPrefix()];

coerce 'RepeatedPublicDelegatedPrefix',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefix'->new($_) } @$_ ] };

declare 'MapStringPublicDelegatedPrefix',
    as HashRef[PublicDelegatedPrefix()];

declare 'ByoipApiVersion',
    as (Int | Str);

declare 'Ipv6AccessType',
    as (Int | Str);

declare 'Mode',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'PublicDelegatedPrefixAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixAggregatedList'];

coerce 'PublicDelegatedPrefixAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixAggregatedList'->new($_) };

declare 'RepeatedPublicDelegatedPrefixAggregatedList',
    as ArrayRef[PublicDelegatedPrefixAggregatedList()];

coerce 'RepeatedPublicDelegatedPrefixAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixAggregatedList'->new($_) } @$_ ] };

declare 'MapStringPublicDelegatedPrefixAggregatedList',
    as HashRef[PublicDelegatedPrefixAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'PublicDelegatedPrefixList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixList'];

coerce 'PublicDelegatedPrefixList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixList'->new($_) };

declare 'RepeatedPublicDelegatedPrefixList',
    as ArrayRef[PublicDelegatedPrefixList()];

coerce 'RepeatedPublicDelegatedPrefixList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixList'->new($_) } @$_ ] };

declare 'MapStringPublicDelegatedPrefixList',
    as HashRef[PublicDelegatedPrefixList()];

declare 'PublicDelegatedPrefixPublicDelegatedSubPrefix',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixPublicDelegatedSubPrefix'];

coerce 'PublicDelegatedPrefixPublicDelegatedSubPrefix',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixPublicDelegatedSubPrefix'->new($_) };

declare 'RepeatedPublicDelegatedPrefixPublicDelegatedSubPrefix',
    as ArrayRef[PublicDelegatedPrefixPublicDelegatedSubPrefix()];

coerce 'RepeatedPublicDelegatedPrefixPublicDelegatedSubPrefix',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixPublicDelegatedSubPrefix'->new($_) } @$_ ] };

declare 'MapStringPublicDelegatedPrefixPublicDelegatedSubPrefix',
    as HashRef[PublicDelegatedPrefixPublicDelegatedSubPrefix()];

declare 'Ipv6AccessType',
    as (Int | Str);

declare 'Mode',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'PublicDelegatedPrefixesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixesScopedList'];

coerce 'PublicDelegatedPrefixesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixesScopedList'->new($_) };

declare 'RepeatedPublicDelegatedPrefixesScopedList',
    as ArrayRef[PublicDelegatedPrefixesScopedList()];

coerce 'RepeatedPublicDelegatedPrefixesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::PublicDelegatedPrefixesScopedList'->new($_) } @$_ ] };

declare 'MapStringPublicDelegatedPrefixesScopedList',
    as HashRef[PublicDelegatedPrefixesScopedList()];

declare 'Quota',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Quota'];

coerce 'Quota',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Quota'->new($_) };

declare 'RepeatedQuota',
    as ArrayRef[Quota()];

coerce 'RepeatedQuota',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Quota'->new($_) } @$_ ] };

declare 'MapStringQuota',
    as HashRef[Quota()];

declare 'Metric',
    as (Int | Str);

declare 'QuotaExceededInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::QuotaExceededInfo'];

coerce 'QuotaExceededInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::QuotaExceededInfo'->new($_) };

declare 'RepeatedQuotaExceededInfo',
    as ArrayRef[QuotaExceededInfo()];

coerce 'RepeatedQuotaExceededInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::QuotaExceededInfo'->new($_) } @$_ ] };

declare 'MapStringQuotaExceededInfo',
    as HashRef[QuotaExceededInfo()];

declare 'RolloutStatus',
    as (Int | Str);

declare 'DimensionsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::QuotaExceededInfo::DimensionsEntry'];

coerce 'DimensionsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::QuotaExceededInfo::DimensionsEntry'->new($_) };

declare 'RepeatedDimensionsEntry',
    as ArrayRef[DimensionsEntry()];

coerce 'RepeatedDimensionsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::QuotaExceededInfo::DimensionsEntry'->new($_) } @$_ ] };

declare 'MapStringDimensionsEntry',
    as HashRef[DimensionsEntry()];

declare 'QuotaStatusWarning',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::QuotaStatusWarning'];

coerce 'QuotaStatusWarning',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::QuotaStatusWarning'->new($_) };

declare 'RepeatedQuotaStatusWarning',
    as ArrayRef[QuotaStatusWarning()];

coerce 'RepeatedQuotaStatusWarning',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::QuotaStatusWarning'->new($_) } @$_ ] };

declare 'MapStringQuotaStatusWarning',
    as HashRef[QuotaStatusWarning()];

declare 'Code',
    as (Int | Str);

declare 'RawDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RawDisk'];

coerce 'RawDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RawDisk'->new($_) };

declare 'RepeatedRawDisk',
    as ArrayRef[RawDisk()];

coerce 'RepeatedRawDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RawDisk'->new($_) } @$_ ] };

declare 'MapStringRawDisk',
    as HashRef[RawDisk()];

declare 'ContainerType',
    as (Int | Str);

declare 'RecreateInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RecreateInstancesInstanceGroupManagerRequest'];

coerce 'RecreateInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RecreateInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedRecreateInstancesInstanceGroupManagerRequest',
    as ArrayRef[RecreateInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedRecreateInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RecreateInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringRecreateInstancesInstanceGroupManagerRequest',
    as HashRef[RecreateInstancesInstanceGroupManagerRequest()];

declare 'RecreateInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RecreateInstancesRegionInstanceGroupManagerRequest'];

coerce 'RecreateInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RecreateInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedRecreateInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[RecreateInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedRecreateInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RecreateInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringRecreateInstancesRegionInstanceGroupManagerRequest',
    as HashRef[RecreateInstancesRegionInstanceGroupManagerRequest()];

declare 'Reference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Reference'];

coerce 'Reference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Reference'->new($_) };

declare 'RepeatedReference',
    as ArrayRef[Reference()];

coerce 'RepeatedReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Reference'->new($_) } @$_ ] };

declare 'MapStringReference',
    as HashRef[Reference()];

declare 'Region',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Region'];

coerce 'Region',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Region'->new($_) };

declare 'RepeatedRegion',
    as ArrayRef[Region()];

coerce 'RepeatedRegion',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Region'->new($_) } @$_ ] };

declare 'MapStringRegion',
    as HashRef[Region()];

declare 'Status',
    as (Int | Str);

declare 'RegionAddressesMoveRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionAddressesMoveRequest'];

coerce 'RegionAddressesMoveRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionAddressesMoveRequest'->new($_) };

declare 'RepeatedRegionAddressesMoveRequest',
    as ArrayRef[RegionAddressesMoveRequest()];

coerce 'RepeatedRegionAddressesMoveRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionAddressesMoveRequest'->new($_) } @$_ ] };

declare 'MapStringRegionAddressesMoveRequest',
    as HashRef[RegionAddressesMoveRequest()];

declare 'RegionAutoscalerList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionAutoscalerList'];

coerce 'RegionAutoscalerList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionAutoscalerList'->new($_) };

declare 'RepeatedRegionAutoscalerList',
    as ArrayRef[RegionAutoscalerList()];

coerce 'RepeatedRegionAutoscalerList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionAutoscalerList'->new($_) } @$_ ] };

declare 'MapStringRegionAutoscalerList',
    as HashRef[RegionAutoscalerList()];

declare 'RegionDiskTypeList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionDiskTypeList'];

coerce 'RegionDiskTypeList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionDiskTypeList'->new($_) };

declare 'RepeatedRegionDiskTypeList',
    as ArrayRef[RegionDiskTypeList()];

coerce 'RepeatedRegionDiskTypeList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionDiskTypeList'->new($_) } @$_ ] };

declare 'MapStringRegionDiskTypeList',
    as HashRef[RegionDiskTypeList()];

declare 'RegionDiskUpdateKmsKeyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionDiskUpdateKmsKeyRequest'];

coerce 'RegionDiskUpdateKmsKeyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionDiskUpdateKmsKeyRequest'->new($_) };

declare 'RepeatedRegionDiskUpdateKmsKeyRequest',
    as ArrayRef[RegionDiskUpdateKmsKeyRequest()];

coerce 'RepeatedRegionDiskUpdateKmsKeyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionDiskUpdateKmsKeyRequest'->new($_) } @$_ ] };

declare 'MapStringRegionDiskUpdateKmsKeyRequest',
    as HashRef[RegionDiskUpdateKmsKeyRequest()];

declare 'RegionDisksAddResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionDisksAddResourcePoliciesRequest'];

coerce 'RegionDisksAddResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionDisksAddResourcePoliciesRequest'->new($_) };

declare 'RepeatedRegionDisksAddResourcePoliciesRequest',
    as ArrayRef[RegionDisksAddResourcePoliciesRequest()];

coerce 'RepeatedRegionDisksAddResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionDisksAddResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionDisksAddResourcePoliciesRequest',
    as HashRef[RegionDisksAddResourcePoliciesRequest()];

declare 'RegionDisksRemoveResourcePoliciesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionDisksRemoveResourcePoliciesRequest'];

coerce 'RegionDisksRemoveResourcePoliciesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionDisksRemoveResourcePoliciesRequest'->new($_) };

declare 'RepeatedRegionDisksRemoveResourcePoliciesRequest',
    as ArrayRef[RegionDisksRemoveResourcePoliciesRequest()];

coerce 'RepeatedRegionDisksRemoveResourcePoliciesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionDisksRemoveResourcePoliciesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionDisksRemoveResourcePoliciesRequest',
    as HashRef[RegionDisksRemoveResourcePoliciesRequest()];

declare 'RegionDisksResizeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionDisksResizeRequest'];

coerce 'RegionDisksResizeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionDisksResizeRequest'->new($_) };

declare 'RepeatedRegionDisksResizeRequest',
    as ArrayRef[RegionDisksResizeRequest()];

coerce 'RepeatedRegionDisksResizeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionDisksResizeRequest'->new($_) } @$_ ] };

declare 'MapStringRegionDisksResizeRequest',
    as HashRef[RegionDisksResizeRequest()];

declare 'RegionDisksStartAsyncReplicationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionDisksStartAsyncReplicationRequest'];

coerce 'RegionDisksStartAsyncReplicationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionDisksStartAsyncReplicationRequest'->new($_) };

declare 'RepeatedRegionDisksStartAsyncReplicationRequest',
    as ArrayRef[RegionDisksStartAsyncReplicationRequest()];

coerce 'RepeatedRegionDisksStartAsyncReplicationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionDisksStartAsyncReplicationRequest'->new($_) } @$_ ] };

declare 'MapStringRegionDisksStartAsyncReplicationRequest',
    as HashRef[RegionDisksStartAsyncReplicationRequest()];

declare 'RegionInstanceGroupList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupList'];

coerce 'RegionInstanceGroupList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupList'->new($_) };

declare 'RepeatedRegionInstanceGroupList',
    as ArrayRef[RegionInstanceGroupList()];

coerce 'RepeatedRegionInstanceGroupList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupList'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupList',
    as HashRef[RegionInstanceGroupList()];

declare 'RegionInstanceGroupManagerDeleteInstanceConfigReq',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerDeleteInstanceConfigReq'];

coerce 'RegionInstanceGroupManagerDeleteInstanceConfigReq',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerDeleteInstanceConfigReq'->new($_) };

declare 'RepeatedRegionInstanceGroupManagerDeleteInstanceConfigReq',
    as ArrayRef[RegionInstanceGroupManagerDeleteInstanceConfigReq()];

coerce 'RepeatedRegionInstanceGroupManagerDeleteInstanceConfigReq',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerDeleteInstanceConfigReq'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagerDeleteInstanceConfigReq',
    as HashRef[RegionInstanceGroupManagerDeleteInstanceConfigReq()];

declare 'RegionInstanceGroupManagerList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerList'];

coerce 'RegionInstanceGroupManagerList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerList'->new($_) };

declare 'RepeatedRegionInstanceGroupManagerList',
    as ArrayRef[RegionInstanceGroupManagerList()];

coerce 'RepeatedRegionInstanceGroupManagerList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerList'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagerList',
    as HashRef[RegionInstanceGroupManagerList()];

declare 'RegionInstanceGroupManagerPatchInstanceConfigReq',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerPatchInstanceConfigReq'];

coerce 'RegionInstanceGroupManagerPatchInstanceConfigReq',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerPatchInstanceConfigReq'->new($_) };

declare 'RepeatedRegionInstanceGroupManagerPatchInstanceConfigReq',
    as ArrayRef[RegionInstanceGroupManagerPatchInstanceConfigReq()];

coerce 'RepeatedRegionInstanceGroupManagerPatchInstanceConfigReq',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerPatchInstanceConfigReq'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagerPatchInstanceConfigReq',
    as HashRef[RegionInstanceGroupManagerPatchInstanceConfigReq()];

declare 'RegionInstanceGroupManagerResizeRequestsListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerResizeRequestsListResponse'];

coerce 'RegionInstanceGroupManagerResizeRequestsListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerResizeRequestsListResponse'->new($_) };

declare 'RepeatedRegionInstanceGroupManagerResizeRequestsListResponse',
    as ArrayRef[RegionInstanceGroupManagerResizeRequestsListResponse()];

coerce 'RepeatedRegionInstanceGroupManagerResizeRequestsListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerResizeRequestsListResponse'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagerResizeRequestsListResponse',
    as HashRef[RegionInstanceGroupManagerResizeRequestsListResponse()];

declare 'RegionInstanceGroupManagerUpdateInstanceConfigReq',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerUpdateInstanceConfigReq'];

coerce 'RegionInstanceGroupManagerUpdateInstanceConfigReq',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerUpdateInstanceConfigReq'->new($_) };

declare 'RepeatedRegionInstanceGroupManagerUpdateInstanceConfigReq',
    as ArrayRef[RegionInstanceGroupManagerUpdateInstanceConfigReq()];

coerce 'RepeatedRegionInstanceGroupManagerUpdateInstanceConfigReq',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagerUpdateInstanceConfigReq'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagerUpdateInstanceConfigReq',
    as HashRef[RegionInstanceGroupManagerUpdateInstanceConfigReq()];

declare 'RegionInstanceGroupManagersAbandonInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersAbandonInstancesRequest'];

coerce 'RegionInstanceGroupManagersAbandonInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersAbandonInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersAbandonInstancesRequest',
    as ArrayRef[RegionInstanceGroupManagersAbandonInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersAbandonInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersAbandonInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersAbandonInstancesRequest',
    as HashRef[RegionInstanceGroupManagersAbandonInstancesRequest()];

declare 'RegionInstanceGroupManagersApplyUpdatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersApplyUpdatesRequest'];

coerce 'RegionInstanceGroupManagersApplyUpdatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersApplyUpdatesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersApplyUpdatesRequest',
    as ArrayRef[RegionInstanceGroupManagersApplyUpdatesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersApplyUpdatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersApplyUpdatesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersApplyUpdatesRequest',
    as HashRef[RegionInstanceGroupManagersApplyUpdatesRequest()];

declare 'MinimalAction',
    as (Int | Str);

declare 'MostDisruptiveAllowedAction',
    as (Int | Str);

declare 'RegionInstanceGroupManagersCreateInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersCreateInstancesRequest'];

coerce 'RegionInstanceGroupManagersCreateInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersCreateInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersCreateInstancesRequest',
    as ArrayRef[RegionInstanceGroupManagersCreateInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersCreateInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersCreateInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersCreateInstancesRequest',
    as HashRef[RegionInstanceGroupManagersCreateInstancesRequest()];

declare 'RegionInstanceGroupManagersDeleteInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersDeleteInstancesRequest'];

coerce 'RegionInstanceGroupManagersDeleteInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersDeleteInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersDeleteInstancesRequest',
    as ArrayRef[RegionInstanceGroupManagersDeleteInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersDeleteInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersDeleteInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersDeleteInstancesRequest',
    as HashRef[RegionInstanceGroupManagersDeleteInstancesRequest()];

declare 'RegionInstanceGroupManagersListErrorsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListErrorsResponse'];

coerce 'RegionInstanceGroupManagersListErrorsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListErrorsResponse'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersListErrorsResponse',
    as ArrayRef[RegionInstanceGroupManagersListErrorsResponse()];

coerce 'RepeatedRegionInstanceGroupManagersListErrorsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListErrorsResponse'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersListErrorsResponse',
    as HashRef[RegionInstanceGroupManagersListErrorsResponse()];

declare 'RegionInstanceGroupManagersListInstanceConfigsResp',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListInstanceConfigsResp'];

coerce 'RegionInstanceGroupManagersListInstanceConfigsResp',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListInstanceConfigsResp'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersListInstanceConfigsResp',
    as ArrayRef[RegionInstanceGroupManagersListInstanceConfigsResp()];

coerce 'RepeatedRegionInstanceGroupManagersListInstanceConfigsResp',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListInstanceConfigsResp'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersListInstanceConfigsResp',
    as HashRef[RegionInstanceGroupManagersListInstanceConfigsResp()];

declare 'RegionInstanceGroupManagersListInstancesResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListInstancesResponse'];

coerce 'RegionInstanceGroupManagersListInstancesResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListInstancesResponse'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersListInstancesResponse',
    as ArrayRef[RegionInstanceGroupManagersListInstancesResponse()];

coerce 'RepeatedRegionInstanceGroupManagersListInstancesResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersListInstancesResponse'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersListInstancesResponse',
    as HashRef[RegionInstanceGroupManagersListInstancesResponse()];

declare 'RegionInstanceGroupManagersRecreateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersRecreateRequest'];

coerce 'RegionInstanceGroupManagersRecreateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersRecreateRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersRecreateRequest',
    as ArrayRef[RegionInstanceGroupManagersRecreateRequest()];

coerce 'RepeatedRegionInstanceGroupManagersRecreateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersRecreateRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersRecreateRequest',
    as HashRef[RegionInstanceGroupManagersRecreateRequest()];

declare 'RegionInstanceGroupManagersResumeInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersResumeInstancesRequest'];

coerce 'RegionInstanceGroupManagersResumeInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersResumeInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersResumeInstancesRequest',
    as ArrayRef[RegionInstanceGroupManagersResumeInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersResumeInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersResumeInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersResumeInstancesRequest',
    as HashRef[RegionInstanceGroupManagersResumeInstancesRequest()];

declare 'RegionInstanceGroupManagersSetTargetPoolsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSetTargetPoolsRequest'];

coerce 'RegionInstanceGroupManagersSetTargetPoolsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSetTargetPoolsRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersSetTargetPoolsRequest',
    as ArrayRef[RegionInstanceGroupManagersSetTargetPoolsRequest()];

coerce 'RepeatedRegionInstanceGroupManagersSetTargetPoolsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSetTargetPoolsRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersSetTargetPoolsRequest',
    as HashRef[RegionInstanceGroupManagersSetTargetPoolsRequest()];

declare 'RegionInstanceGroupManagersSetTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSetTemplateRequest'];

coerce 'RegionInstanceGroupManagersSetTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSetTemplateRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersSetTemplateRequest',
    as ArrayRef[RegionInstanceGroupManagersSetTemplateRequest()];

coerce 'RepeatedRegionInstanceGroupManagersSetTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSetTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersSetTemplateRequest',
    as HashRef[RegionInstanceGroupManagersSetTemplateRequest()];

declare 'RegionInstanceGroupManagersStartInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersStartInstancesRequest'];

coerce 'RegionInstanceGroupManagersStartInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersStartInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersStartInstancesRequest',
    as ArrayRef[RegionInstanceGroupManagersStartInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersStartInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersStartInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersStartInstancesRequest',
    as HashRef[RegionInstanceGroupManagersStartInstancesRequest()];

declare 'RegionInstanceGroupManagersStopInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersStopInstancesRequest'];

coerce 'RegionInstanceGroupManagersStopInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersStopInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersStopInstancesRequest',
    as ArrayRef[RegionInstanceGroupManagersStopInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersStopInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersStopInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersStopInstancesRequest',
    as HashRef[RegionInstanceGroupManagersStopInstancesRequest()];

declare 'RegionInstanceGroupManagersSuspendInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSuspendInstancesRequest'];

coerce 'RegionInstanceGroupManagersSuspendInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSuspendInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupManagersSuspendInstancesRequest',
    as ArrayRef[RegionInstanceGroupManagersSuspendInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupManagersSuspendInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupManagersSuspendInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupManagersSuspendInstancesRequest',
    as HashRef[RegionInstanceGroupManagersSuspendInstancesRequest()];

declare 'RegionInstanceGroupsListInstances',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsListInstances'];

coerce 'RegionInstanceGroupsListInstances',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsListInstances'->new($_) };

declare 'RepeatedRegionInstanceGroupsListInstances',
    as ArrayRef[RegionInstanceGroupsListInstances()];

coerce 'RepeatedRegionInstanceGroupsListInstances',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsListInstances'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupsListInstances',
    as HashRef[RegionInstanceGroupsListInstances()];

declare 'RegionInstanceGroupsListInstancesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsListInstancesRequest'];

coerce 'RegionInstanceGroupsListInstancesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsListInstancesRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupsListInstancesRequest',
    as ArrayRef[RegionInstanceGroupsListInstancesRequest()];

coerce 'RepeatedRegionInstanceGroupsListInstancesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsListInstancesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupsListInstancesRequest',
    as HashRef[RegionInstanceGroupsListInstancesRequest()];

declare 'InstanceState',
    as (Int | Str);

declare 'RegionInstanceGroupsSetNamedPortsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsSetNamedPortsRequest'];

coerce 'RegionInstanceGroupsSetNamedPortsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsSetNamedPortsRequest'->new($_) };

declare 'RepeatedRegionInstanceGroupsSetNamedPortsRequest',
    as ArrayRef[RegionInstanceGroupsSetNamedPortsRequest()];

coerce 'RepeatedRegionInstanceGroupsSetNamedPortsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionInstanceGroupsSetNamedPortsRequest'->new($_) } @$_ ] };

declare 'MapStringRegionInstanceGroupsSetNamedPortsRequest',
    as HashRef[RegionInstanceGroupsSetNamedPortsRequest()];

declare 'RegionList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionList'];

coerce 'RegionList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionList'->new($_) };

declare 'RepeatedRegionList',
    as ArrayRef[RegionList()];

coerce 'RepeatedRegionList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionList'->new($_) } @$_ ] };

declare 'MapStringRegionList',
    as HashRef[RegionList()];

declare 'RegionNetworkEndpointGroupsAttachEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionNetworkEndpointGroupsAttachEndpointsRequest'];

coerce 'RegionNetworkEndpointGroupsAttachEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionNetworkEndpointGroupsAttachEndpointsRequest'->new($_) };

declare 'RepeatedRegionNetworkEndpointGroupsAttachEndpointsRequest',
    as ArrayRef[RegionNetworkEndpointGroupsAttachEndpointsRequest()];

coerce 'RepeatedRegionNetworkEndpointGroupsAttachEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionNetworkEndpointGroupsAttachEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringRegionNetworkEndpointGroupsAttachEndpointsRequest',
    as HashRef[RegionNetworkEndpointGroupsAttachEndpointsRequest()];

declare 'RegionNetworkEndpointGroupsDetachEndpointsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionNetworkEndpointGroupsDetachEndpointsRequest'];

coerce 'RegionNetworkEndpointGroupsDetachEndpointsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionNetworkEndpointGroupsDetachEndpointsRequest'->new($_) };

declare 'RepeatedRegionNetworkEndpointGroupsDetachEndpointsRequest',
    as ArrayRef[RegionNetworkEndpointGroupsDetachEndpointsRequest()];

coerce 'RepeatedRegionNetworkEndpointGroupsDetachEndpointsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionNetworkEndpointGroupsDetachEndpointsRequest'->new($_) } @$_ ] };

declare 'MapStringRegionNetworkEndpointGroupsDetachEndpointsRequest',
    as HashRef[RegionNetworkEndpointGroupsDetachEndpointsRequest()];

declare 'RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse'];

coerce 'RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse'->new($_) };

declare 'RepeatedRegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse',
    as ArrayRef[RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse()];

coerce 'RepeatedRegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse'->new($_) } @$_ ] };

declare 'MapStringRegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse',
    as HashRef[RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse()];

declare 'RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy'];

coerce 'RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy'->new($_) };

declare 'RepeatedRegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as ArrayRef[RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy()];

coerce 'RepeatedRegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy'->new($_) } @$_ ] };

declare 'MapStringRegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy',
    as HashRef[RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponseEffectiveFirewallPolicy()];

declare 'Type',
    as (Int | Str);

declare 'RegionSetLabelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionSetLabelsRequest'];

coerce 'RegionSetLabelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionSetLabelsRequest'->new($_) };

declare 'RepeatedRegionSetLabelsRequest',
    as ArrayRef[RegionSetLabelsRequest()];

coerce 'RepeatedRegionSetLabelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionSetLabelsRequest'->new($_) } @$_ ] };

declare 'MapStringRegionSetLabelsRequest',
    as HashRef[RegionSetLabelsRequest()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionSetLabelsRequest::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionSetLabelsRequest::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionSetLabelsRequest::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'RegionSetPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionSetPolicyRequest'];

coerce 'RegionSetPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionSetPolicyRequest'->new($_) };

declare 'RepeatedRegionSetPolicyRequest',
    as ArrayRef[RegionSetPolicyRequest()];

coerce 'RepeatedRegionSetPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionSetPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRegionSetPolicyRequest',
    as HashRef[RegionSetPolicyRequest()];

declare 'RegionSnapshotUpdateKmsKeyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionSnapshotUpdateKmsKeyRequest'];

coerce 'RegionSnapshotUpdateKmsKeyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionSnapshotUpdateKmsKeyRequest'->new($_) };

declare 'RepeatedRegionSnapshotUpdateKmsKeyRequest',
    as ArrayRef[RegionSnapshotUpdateKmsKeyRequest()];

coerce 'RepeatedRegionSnapshotUpdateKmsKeyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionSnapshotUpdateKmsKeyRequest'->new($_) } @$_ ] };

declare 'MapStringRegionSnapshotUpdateKmsKeyRequest',
    as HashRef[RegionSnapshotUpdateKmsKeyRequest()];

declare 'RegionTargetHttpsProxiesSetSslCertificatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionTargetHttpsProxiesSetSslCertificatesRequest'];

coerce 'RegionTargetHttpsProxiesSetSslCertificatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionTargetHttpsProxiesSetSslCertificatesRequest'->new($_) };

declare 'RepeatedRegionTargetHttpsProxiesSetSslCertificatesRequest',
    as ArrayRef[RegionTargetHttpsProxiesSetSslCertificatesRequest()];

coerce 'RepeatedRegionTargetHttpsProxiesSetSslCertificatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionTargetHttpsProxiesSetSslCertificatesRequest'->new($_) } @$_ ] };

declare 'MapStringRegionTargetHttpsProxiesSetSslCertificatesRequest',
    as HashRef[RegionTargetHttpsProxiesSetSslCertificatesRequest()];

declare 'RegionUrlMapsValidateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RegionUrlMapsValidateRequest'];

coerce 'RegionUrlMapsValidateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RegionUrlMapsValidateRequest'->new($_) };

declare 'RepeatedRegionUrlMapsValidateRequest',
    as ArrayRef[RegionUrlMapsValidateRequest()];

coerce 'RepeatedRegionUrlMapsValidateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RegionUrlMapsValidateRequest'->new($_) } @$_ ] };

declare 'MapStringRegionUrlMapsValidateRequest',
    as HashRef[RegionUrlMapsValidateRequest()];

declare 'RemoveAssociationFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveAssociationFirewallPolicyRequest'];

coerce 'RemoveAssociationFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationFirewallPolicyRequest'->new($_) };

declare 'RepeatedRemoveAssociationFirewallPolicyRequest',
    as ArrayRef[RemoveAssociationFirewallPolicyRequest()];

coerce 'RepeatedRemoveAssociationFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveAssociationFirewallPolicyRequest',
    as HashRef[RemoveAssociationFirewallPolicyRequest()];

declare 'RemoveAssociationNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveAssociationNetworkFirewallPolicyRequest'];

coerce 'RemoveAssociationNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedRemoveAssociationNetworkFirewallPolicyRequest',
    as ArrayRef[RemoveAssociationNetworkFirewallPolicyRequest()];

coerce 'RepeatedRemoveAssociationNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveAssociationNetworkFirewallPolicyRequest',
    as HashRef[RemoveAssociationNetworkFirewallPolicyRequest()];

declare 'RemoveAssociationOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveAssociationOrganizationSecurityPolicyRequest'];

coerce 'RemoveAssociationOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedRemoveAssociationOrganizationSecurityPolicyRequest',
    as ArrayRef[RemoveAssociationOrganizationSecurityPolicyRequest()];

coerce 'RepeatedRemoveAssociationOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveAssociationOrganizationSecurityPolicyRequest',
    as HashRef[RemoveAssociationOrganizationSecurityPolicyRequest()];

declare 'RemoveAssociationRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveAssociationRegionNetworkFirewallPolicyRequest'];

coerce 'RemoveAssociationRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedRemoveAssociationRegionNetworkFirewallPolicyRequest',
    as ArrayRef[RemoveAssociationRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedRemoveAssociationRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveAssociationRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveAssociationRegionNetworkFirewallPolicyRequest',
    as HashRef[RemoveAssociationRegionNetworkFirewallPolicyRequest()];

declare 'RemoveHealthCheckTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveHealthCheckTargetPoolRequest'];

coerce 'RemoveHealthCheckTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveHealthCheckTargetPoolRequest'->new($_) };

declare 'RepeatedRemoveHealthCheckTargetPoolRequest',
    as ArrayRef[RemoveHealthCheckTargetPoolRequest()];

coerce 'RepeatedRemoveHealthCheckTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveHealthCheckTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveHealthCheckTargetPoolRequest',
    as HashRef[RemoveHealthCheckTargetPoolRequest()];

declare 'RemoveInstanceTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveInstanceTargetPoolRequest'];

coerce 'RemoveInstanceTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveInstanceTargetPoolRequest'->new($_) };

declare 'RepeatedRemoveInstanceTargetPoolRequest',
    as ArrayRef[RemoveInstanceTargetPoolRequest()];

coerce 'RepeatedRemoveInstanceTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveInstanceTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveInstanceTargetPoolRequest',
    as HashRef[RemoveInstanceTargetPoolRequest()];

declare 'RemoveInstancesInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveInstancesInstanceGroupRequest'];

coerce 'RemoveInstancesInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveInstancesInstanceGroupRequest'->new($_) };

declare 'RepeatedRemoveInstancesInstanceGroupRequest',
    as ArrayRef[RemoveInstancesInstanceGroupRequest()];

coerce 'RepeatedRemoveInstancesInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveInstancesInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveInstancesInstanceGroupRequest',
    as HashRef[RemoveInstancesInstanceGroupRequest()];

declare 'RemovePacketMirroringRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemovePacketMirroringRuleNetworkFirewallPolicyRequest'];

coerce 'RemovePacketMirroringRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemovePacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedRemovePacketMirroringRuleNetworkFirewallPolicyRequest',
    as ArrayRef[RemovePacketMirroringRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedRemovePacketMirroringRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemovePacketMirroringRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemovePacketMirroringRuleNetworkFirewallPolicyRequest',
    as HashRef[RemovePacketMirroringRuleNetworkFirewallPolicyRequest()];

declare 'RemovePeeringNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemovePeeringNetworkRequest'];

coerce 'RemovePeeringNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemovePeeringNetworkRequest'->new($_) };

declare 'RepeatedRemovePeeringNetworkRequest',
    as ArrayRef[RemovePeeringNetworkRequest()];

coerce 'RepeatedRemovePeeringNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemovePeeringNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringRemovePeeringNetworkRequest',
    as HashRef[RemovePeeringNetworkRequest()];

declare 'RemoveResourcePoliciesDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesDiskRequest'];

coerce 'RemoveResourcePoliciesDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesDiskRequest'->new($_) };

declare 'RepeatedRemoveResourcePoliciesDiskRequest',
    as ArrayRef[RemoveResourcePoliciesDiskRequest()];

coerce 'RepeatedRemoveResourcePoliciesDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesDiskRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveResourcePoliciesDiskRequest',
    as HashRef[RemoveResourcePoliciesDiskRequest()];

declare 'RemoveResourcePoliciesInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesInstanceRequest'];

coerce 'RemoveResourcePoliciesInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesInstanceRequest'->new($_) };

declare 'RepeatedRemoveResourcePoliciesInstanceRequest',
    as ArrayRef[RemoveResourcePoliciesInstanceRequest()];

coerce 'RepeatedRemoveResourcePoliciesInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveResourcePoliciesInstanceRequest',
    as HashRef[RemoveResourcePoliciesInstanceRequest()];

declare 'RemoveResourcePoliciesRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesRegionDiskRequest'];

coerce 'RemoveResourcePoliciesRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesRegionDiskRequest'->new($_) };

declare 'RepeatedRemoveResourcePoliciesRegionDiskRequest',
    as ArrayRef[RemoveResourcePoliciesRegionDiskRequest()];

coerce 'RepeatedRemoveResourcePoliciesRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveResourcePoliciesRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveResourcePoliciesRegionDiskRequest',
    as HashRef[RemoveResourcePoliciesRegionDiskRequest()];

declare 'RemoveRuleFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveRuleFirewallPolicyRequest'];

coerce 'RemoveRuleFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveRuleFirewallPolicyRequest'->new($_) };

declare 'RepeatedRemoveRuleFirewallPolicyRequest',
    as ArrayRef[RemoveRuleFirewallPolicyRequest()];

coerce 'RepeatedRemoveRuleFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveRuleFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveRuleFirewallPolicyRequest',
    as HashRef[RemoveRuleFirewallPolicyRequest()];

declare 'RemoveRuleNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveRuleNetworkFirewallPolicyRequest'];

coerce 'RemoveRuleNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveRuleNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedRemoveRuleNetworkFirewallPolicyRequest',
    as ArrayRef[RemoveRuleNetworkFirewallPolicyRequest()];

coerce 'RepeatedRemoveRuleNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveRuleNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveRuleNetworkFirewallPolicyRequest',
    as HashRef[RemoveRuleNetworkFirewallPolicyRequest()];

declare 'RemoveRuleOrganizationSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveRuleOrganizationSecurityPolicyRequest'];

coerce 'RemoveRuleOrganizationSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveRuleOrganizationSecurityPolicyRequest'->new($_) };

declare 'RepeatedRemoveRuleOrganizationSecurityPolicyRequest',
    as ArrayRef[RemoveRuleOrganizationSecurityPolicyRequest()];

coerce 'RepeatedRemoveRuleOrganizationSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveRuleOrganizationSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveRuleOrganizationSecurityPolicyRequest',
    as HashRef[RemoveRuleOrganizationSecurityPolicyRequest()];

declare 'RemoveRuleRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveRuleRegionNetworkFirewallPolicyRequest'];

coerce 'RemoveRuleRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveRuleRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedRemoveRuleRegionNetworkFirewallPolicyRequest',
    as ArrayRef[RemoveRuleRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedRemoveRuleRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveRuleRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveRuleRegionNetworkFirewallPolicyRequest',
    as HashRef[RemoveRuleRegionNetworkFirewallPolicyRequest()];

declare 'RemoveRuleRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveRuleRegionSecurityPolicyRequest'];

coerce 'RemoveRuleRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveRuleRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedRemoveRuleRegionSecurityPolicyRequest',
    as ArrayRef[RemoveRuleRegionSecurityPolicyRequest()];

coerce 'RepeatedRemoveRuleRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveRuleRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveRuleRegionSecurityPolicyRequest',
    as HashRef[RemoveRuleRegionSecurityPolicyRequest()];

declare 'RemoveRuleSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RemoveRuleSecurityPolicyRequest'];

coerce 'RemoveRuleSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RemoveRuleSecurityPolicyRequest'->new($_) };

declare 'RepeatedRemoveRuleSecurityPolicyRequest',
    as ArrayRef[RemoveRuleSecurityPolicyRequest()];

coerce 'RepeatedRemoveRuleSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RemoveRuleSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringRemoveRuleSecurityPolicyRequest',
    as HashRef[RemoveRuleSecurityPolicyRequest()];

declare 'ReportFaultyReservationSubBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReportFaultyReservationSubBlockRequest'];

coerce 'ReportFaultyReservationSubBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReportFaultyReservationSubBlockRequest'->new($_) };

declare 'RepeatedReportFaultyReservationSubBlockRequest',
    as ArrayRef[ReportFaultyReservationSubBlockRequest()];

coerce 'RepeatedReportFaultyReservationSubBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReportFaultyReservationSubBlockRequest'->new($_) } @$_ ] };

declare 'MapStringReportFaultyReservationSubBlockRequest',
    as HashRef[ReportFaultyReservationSubBlockRequest()];

declare 'ReportHostAsFaultyInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReportHostAsFaultyInstanceRequest'];

coerce 'ReportHostAsFaultyInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReportHostAsFaultyInstanceRequest'->new($_) };

declare 'RepeatedReportHostAsFaultyInstanceRequest',
    as ArrayRef[ReportHostAsFaultyInstanceRequest()];

coerce 'RepeatedReportHostAsFaultyInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReportHostAsFaultyInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringReportHostAsFaultyInstanceRequest',
    as HashRef[ReportHostAsFaultyInstanceRequest()];

declare 'RequestMirrorPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RequestMirrorPolicy'];

coerce 'RequestMirrorPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RequestMirrorPolicy'->new($_) };

declare 'RepeatedRequestMirrorPolicy',
    as ArrayRef[RequestMirrorPolicy()];

coerce 'RepeatedRequestMirrorPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RequestMirrorPolicy'->new($_) } @$_ ] };

declare 'MapStringRequestMirrorPolicy',
    as HashRef[RequestMirrorPolicy()];

declare 'RequestRemovePeeringNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RequestRemovePeeringNetworkRequest'];

coerce 'RequestRemovePeeringNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RequestRemovePeeringNetworkRequest'->new($_) };

declare 'RepeatedRequestRemovePeeringNetworkRequest',
    as ArrayRef[RequestRemovePeeringNetworkRequest()];

coerce 'RepeatedRequestRemovePeeringNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RequestRemovePeeringNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringRequestRemovePeeringNetworkRequest',
    as HashRef[RequestRemovePeeringNetworkRequest()];

declare 'Reservation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Reservation'];

coerce 'Reservation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Reservation'->new($_) };

declare 'RepeatedReservation',
    as ArrayRef[Reservation()];

coerce 'RepeatedReservation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Reservation'->new($_) } @$_ ] };

declare 'MapStringReservation',
    as HashRef[Reservation()];

declare 'ConfidentialComputeType',
    as (Int | Str);

declare 'DeploymentType',
    as (Int | Str);

declare 'EarlyAccessMaintenance',
    as (Int | Str);

declare 'ProtectionTier',
    as (Int | Str);

declare 'SchedulingType',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'ResourcePoliciesEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Reservation::ResourcePoliciesEntry'];

coerce 'ResourcePoliciesEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Reservation::ResourcePoliciesEntry'->new($_) };

declare 'RepeatedResourcePoliciesEntry',
    as ArrayRef[ResourcePoliciesEntry()];

coerce 'RepeatedResourcePoliciesEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Reservation::ResourcePoliciesEntry'->new($_) } @$_ ] };

declare 'MapStringResourcePoliciesEntry',
    as HashRef[ResourcePoliciesEntry()];

declare 'ReservationAdvancedDeploymentControl',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationAdvancedDeploymentControl'];

coerce 'ReservationAdvancedDeploymentControl',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationAdvancedDeploymentControl'->new($_) };

declare 'RepeatedReservationAdvancedDeploymentControl',
    as ArrayRef[ReservationAdvancedDeploymentControl()];

coerce 'RepeatedReservationAdvancedDeploymentControl',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationAdvancedDeploymentControl'->new($_) } @$_ ] };

declare 'MapStringReservationAdvancedDeploymentControl',
    as HashRef[ReservationAdvancedDeploymentControl()];

declare 'ReservationOperationalMode',
    as (Int | Str);

declare 'ReservationAffinity',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationAffinity'];

coerce 'ReservationAffinity',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationAffinity'->new($_) };

declare 'RepeatedReservationAffinity',
    as ArrayRef[ReservationAffinity()];

coerce 'RepeatedReservationAffinity',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationAffinity'->new($_) } @$_ ] };

declare 'MapStringReservationAffinity',
    as HashRef[ReservationAffinity()];

declare 'ConsumeReservationType',
    as (Int | Str);

declare 'ReservationAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationAggregatedList'];

coerce 'ReservationAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationAggregatedList'->new($_) };

declare 'RepeatedReservationAggregatedList',
    as ArrayRef[ReservationAggregatedList()];

coerce 'RepeatedReservationAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationAggregatedList'->new($_) } @$_ ] };

declare 'MapStringReservationAggregatedList',
    as HashRef[ReservationAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'ReservationBlock',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationBlock'];

coerce 'ReservationBlock',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationBlock'->new($_) };

declare 'RepeatedReservationBlock',
    as ArrayRef[ReservationBlock()];

coerce 'RepeatedReservationBlock',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationBlock'->new($_) } @$_ ] };

declare 'MapStringReservationBlock',
    as HashRef[ReservationBlock()];

declare 'Status',
    as (Int | Str);

declare 'ReservationBlockHealthInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationBlockHealthInfo'];

coerce 'ReservationBlockHealthInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationBlockHealthInfo'->new($_) };

declare 'RepeatedReservationBlockHealthInfo',
    as ArrayRef[ReservationBlockHealthInfo()];

coerce 'RepeatedReservationBlockHealthInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationBlockHealthInfo'->new($_) } @$_ ] };

declare 'MapStringReservationBlockHealthInfo',
    as HashRef[ReservationBlockHealthInfo()];

declare 'HealthStatus',
    as (Int | Str);

declare 'ReservationBlockPhysicalTopology',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopology'];

coerce 'ReservationBlockPhysicalTopology',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopology'->new($_) };

declare 'RepeatedReservationBlockPhysicalTopology',
    as ArrayRef[ReservationBlockPhysicalTopology()];

coerce 'RepeatedReservationBlockPhysicalTopology',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopology'->new($_) } @$_ ] };

declare 'MapStringReservationBlockPhysicalTopology',
    as HashRef[ReservationBlockPhysicalTopology()];

declare 'ReservationBlockPhysicalTopologyInstance',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopologyInstance'];

coerce 'ReservationBlockPhysicalTopologyInstance',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopologyInstance'->new($_) };

declare 'RepeatedReservationBlockPhysicalTopologyInstance',
    as ArrayRef[ReservationBlockPhysicalTopologyInstance()];

coerce 'RepeatedReservationBlockPhysicalTopologyInstance',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopologyInstance'->new($_) } @$_ ] };

declare 'MapStringReservationBlockPhysicalTopologyInstance',
    as HashRef[ReservationBlockPhysicalTopologyInstance()];

declare 'ReservationBlockPhysicalTopologyInstancePhysicalHostTopology',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopologyInstancePhysicalHostTopology'];

coerce 'ReservationBlockPhysicalTopologyInstancePhysicalHostTopology',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopologyInstancePhysicalHostTopology'->new($_) };

declare 'RepeatedReservationBlockPhysicalTopologyInstancePhysicalHostTopology',
    as ArrayRef[ReservationBlockPhysicalTopologyInstancePhysicalHostTopology()];

coerce 'RepeatedReservationBlockPhysicalTopologyInstancePhysicalHostTopology',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationBlockPhysicalTopologyInstancePhysicalHostTopology'->new($_) } @$_ ] };

declare 'MapStringReservationBlockPhysicalTopologyInstancePhysicalHostTopology',
    as HashRef[ReservationBlockPhysicalTopologyInstancePhysicalHostTopology()];

declare 'ReservationBlocksGetResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationBlocksGetResponse'];

coerce 'ReservationBlocksGetResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationBlocksGetResponse'->new($_) };

declare 'RepeatedReservationBlocksGetResponse',
    as ArrayRef[ReservationBlocksGetResponse()];

coerce 'RepeatedReservationBlocksGetResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationBlocksGetResponse'->new($_) } @$_ ] };

declare 'MapStringReservationBlocksGetResponse',
    as HashRef[ReservationBlocksGetResponse()];

declare 'ReservationBlocksListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationBlocksListResponse'];

coerce 'ReservationBlocksListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationBlocksListResponse'->new($_) };

declare 'RepeatedReservationBlocksListResponse',
    as ArrayRef[ReservationBlocksListResponse()];

coerce 'RepeatedReservationBlocksListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationBlocksListResponse'->new($_) } @$_ ] };

declare 'MapStringReservationBlocksListResponse',
    as HashRef[ReservationBlocksListResponse()];

declare 'ReservationList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationList'];

coerce 'ReservationList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationList'->new($_) };

declare 'RepeatedReservationList',
    as ArrayRef[ReservationList()];

coerce 'RepeatedReservationList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationList'->new($_) } @$_ ] };

declare 'MapStringReservationList',
    as HashRef[ReservationList()];

declare 'ReservationParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationParams'];

coerce 'ReservationParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationParams'->new($_) };

declare 'RepeatedReservationParams',
    as ArrayRef[ReservationParams()];

coerce 'RepeatedReservationParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationParams'->new($_) } @$_ ] };

declare 'MapStringReservationParams',
    as HashRef[ReservationParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'ReservationSlot',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSlot'];

coerce 'ReservationSlot',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSlot'->new($_) };

declare 'RepeatedReservationSlot',
    as ArrayRef[ReservationSlot()];

coerce 'RepeatedReservationSlot',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSlot'->new($_) } @$_ ] };

declare 'MapStringReservationSlot',
    as HashRef[ReservationSlot()];

declare 'State',
    as (Int | Str);

declare 'ReservationSlotPhysicalTopology',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSlotPhysicalTopology'];

coerce 'ReservationSlotPhysicalTopology',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSlotPhysicalTopology'->new($_) };

declare 'RepeatedReservationSlotPhysicalTopology',
    as ArrayRef[ReservationSlotPhysicalTopology()];

coerce 'RepeatedReservationSlotPhysicalTopology',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSlotPhysicalTopology'->new($_) } @$_ ] };

declare 'MapStringReservationSlotPhysicalTopology',
    as HashRef[ReservationSlotPhysicalTopology()];

declare 'ReservationSlotStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSlotStatus'];

coerce 'ReservationSlotStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSlotStatus'->new($_) };

declare 'RepeatedReservationSlotStatus',
    as ArrayRef[ReservationSlotStatus()];

coerce 'RepeatedReservationSlotStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSlotStatus'->new($_) } @$_ ] };

declare 'MapStringReservationSlotStatus',
    as HashRef[ReservationSlotStatus()];

declare 'ReservationSlotsGetResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSlotsGetResponse'];

coerce 'ReservationSlotsGetResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSlotsGetResponse'->new($_) };

declare 'RepeatedReservationSlotsGetResponse',
    as ArrayRef[ReservationSlotsGetResponse()];

coerce 'RepeatedReservationSlotsGetResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSlotsGetResponse'->new($_) } @$_ ] };

declare 'MapStringReservationSlotsGetResponse',
    as HashRef[ReservationSlotsGetResponse()];

declare 'ReservationSlotsGetVersionRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSlotsGetVersionRequest'];

coerce 'ReservationSlotsGetVersionRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSlotsGetVersionRequest'->new($_) };

declare 'RepeatedReservationSlotsGetVersionRequest',
    as ArrayRef[ReservationSlotsGetVersionRequest()];

coerce 'RepeatedReservationSlotsGetVersionRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSlotsGetVersionRequest'->new($_) } @$_ ] };

declare 'MapStringReservationSlotsGetVersionRequest',
    as HashRef[ReservationSlotsGetVersionRequest()];

declare 'SbomSelections',
    as (Int | Str);

declare 'ReservationSlotsListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSlotsListResponse'];

coerce 'ReservationSlotsListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSlotsListResponse'->new($_) };

declare 'RepeatedReservationSlotsListResponse',
    as ArrayRef[ReservationSlotsListResponse()];

coerce 'RepeatedReservationSlotsListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSlotsListResponse'->new($_) } @$_ ] };

declare 'MapStringReservationSlotsListResponse',
    as HashRef[ReservationSlotsListResponse()];

declare 'ReservationSubBlock',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlock'];

coerce 'ReservationSubBlock',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlock'->new($_) };

declare 'RepeatedReservationSubBlock',
    as ArrayRef[ReservationSubBlock()];

coerce 'RepeatedReservationSubBlock',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlock'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlock',
    as HashRef[ReservationSubBlock()];

declare 'Status',
    as (Int | Str);

declare 'ReservationSubBlockHealthInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlockHealthInfo'];

coerce 'ReservationSubBlockHealthInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlockHealthInfo'->new($_) };

declare 'RepeatedReservationSubBlockHealthInfo',
    as ArrayRef[ReservationSubBlockHealthInfo()];

coerce 'RepeatedReservationSubBlockHealthInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlockHealthInfo'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlockHealthInfo',
    as HashRef[ReservationSubBlockHealthInfo()];

declare 'HealthStatus',
    as (Int | Str);

declare 'ReservationSubBlockPhysicalTopology',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlockPhysicalTopology'];

coerce 'ReservationSubBlockPhysicalTopology',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlockPhysicalTopology'->new($_) };

declare 'RepeatedReservationSubBlockPhysicalTopology',
    as ArrayRef[ReservationSubBlockPhysicalTopology()];

coerce 'RepeatedReservationSubBlockPhysicalTopology',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlockPhysicalTopology'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlockPhysicalTopology',
    as HashRef[ReservationSubBlockPhysicalTopology()];

declare 'ReservationSubBlocksGetResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlocksGetResponse'];

coerce 'ReservationSubBlocksGetResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksGetResponse'->new($_) };

declare 'RepeatedReservationSubBlocksGetResponse',
    as ArrayRef[ReservationSubBlocksGetResponse()];

coerce 'RepeatedReservationSubBlocksGetResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksGetResponse'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlocksGetResponse',
    as HashRef[ReservationSubBlocksGetResponse()];

declare 'ReservationSubBlocksGetVersionRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlocksGetVersionRequest'];

coerce 'ReservationSubBlocksGetVersionRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksGetVersionRequest'->new($_) };

declare 'RepeatedReservationSubBlocksGetVersionRequest',
    as ArrayRef[ReservationSubBlocksGetVersionRequest()];

coerce 'RepeatedReservationSubBlocksGetVersionRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksGetVersionRequest'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlocksGetVersionRequest',
    as HashRef[ReservationSubBlocksGetVersionRequest()];

declare 'SbomSelections',
    as (Int | Str);

declare 'ReservationSubBlocksListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlocksListResponse'];

coerce 'ReservationSubBlocksListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksListResponse'->new($_) };

declare 'RepeatedReservationSubBlocksListResponse',
    as ArrayRef[ReservationSubBlocksListResponse()];

coerce 'RepeatedReservationSubBlocksListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksListResponse'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlocksListResponse',
    as HashRef[ReservationSubBlocksListResponse()];

declare 'ReservationSubBlocksReportFaultyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlocksReportFaultyRequest'];

coerce 'ReservationSubBlocksReportFaultyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksReportFaultyRequest'->new($_) };

declare 'RepeatedReservationSubBlocksReportFaultyRequest',
    as ArrayRef[ReservationSubBlocksReportFaultyRequest()];

coerce 'RepeatedReservationSubBlocksReportFaultyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksReportFaultyRequest'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlocksReportFaultyRequest',
    as HashRef[ReservationSubBlocksReportFaultyRequest()];

declare 'DisruptionSchedule',
    as (Int | Str);

declare 'FailureComponent',
    as (Int | Str);

declare 'ReservationSubBlocksReportFaultyRequestFaultReason',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationSubBlocksReportFaultyRequestFaultReason'];

coerce 'ReservationSubBlocksReportFaultyRequestFaultReason',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksReportFaultyRequestFaultReason'->new($_) };

declare 'RepeatedReservationSubBlocksReportFaultyRequestFaultReason',
    as ArrayRef[ReservationSubBlocksReportFaultyRequestFaultReason()];

coerce 'RepeatedReservationSubBlocksReportFaultyRequestFaultReason',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationSubBlocksReportFaultyRequestFaultReason'->new($_) } @$_ ] };

declare 'MapStringReservationSubBlocksReportFaultyRequestFaultReason',
    as HashRef[ReservationSubBlocksReportFaultyRequestFaultReason()];

declare 'Behavior',
    as (Int | Str);

declare 'ReservationsBlocksPerformMaintenanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationsBlocksPerformMaintenanceRequest'];

coerce 'ReservationsBlocksPerformMaintenanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationsBlocksPerformMaintenanceRequest'->new($_) };

declare 'RepeatedReservationsBlocksPerformMaintenanceRequest',
    as ArrayRef[ReservationsBlocksPerformMaintenanceRequest()];

coerce 'RepeatedReservationsBlocksPerformMaintenanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationsBlocksPerformMaintenanceRequest'->new($_) } @$_ ] };

declare 'MapStringReservationsBlocksPerformMaintenanceRequest',
    as HashRef[ReservationsBlocksPerformMaintenanceRequest()];

declare 'MaintenanceScope',
    as (Int | Str);

declare 'ReservationsPerformMaintenanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationsPerformMaintenanceRequest'];

coerce 'ReservationsPerformMaintenanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationsPerformMaintenanceRequest'->new($_) };

declare 'RepeatedReservationsPerformMaintenanceRequest',
    as ArrayRef[ReservationsPerformMaintenanceRequest()];

coerce 'RepeatedReservationsPerformMaintenanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationsPerformMaintenanceRequest'->new($_) } @$_ ] };

declare 'MapStringReservationsPerformMaintenanceRequest',
    as HashRef[ReservationsPerformMaintenanceRequest()];

declare 'MaintenanceScope',
    as (Int | Str);

declare 'ReservationsResizeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationsResizeRequest'];

coerce 'ReservationsResizeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationsResizeRequest'->new($_) };

declare 'RepeatedReservationsResizeRequest',
    as ArrayRef[ReservationsResizeRequest()];

coerce 'RepeatedReservationsResizeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationsResizeRequest'->new($_) } @$_ ] };

declare 'MapStringReservationsResizeRequest',
    as HashRef[ReservationsResizeRequest()];

declare 'ReservationsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ReservationsScopedList'];

coerce 'ReservationsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ReservationsScopedList'->new($_) };

declare 'RepeatedReservationsScopedList',
    as ArrayRef[ReservationsScopedList()];

coerce 'RepeatedReservationsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ReservationsScopedList'->new($_) } @$_ ] };

declare 'MapStringReservationsScopedList',
    as HashRef[ReservationsScopedList()];

declare 'ResetInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResetInstanceRequest'];

coerce 'ResetInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResetInstanceRequest'->new($_) };

declare 'RepeatedResetInstanceRequest',
    as ArrayRef[ResetInstanceRequest()];

coerce 'RepeatedResetInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResetInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringResetInstanceRequest',
    as HashRef[ResetInstanceRequest()];

declare 'ResizeDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResizeDiskRequest'];

coerce 'ResizeDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResizeDiskRequest'->new($_) };

declare 'RepeatedResizeDiskRequest',
    as ArrayRef[ResizeDiskRequest()];

coerce 'RepeatedResizeDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResizeDiskRequest'->new($_) } @$_ ] };

declare 'MapStringResizeDiskRequest',
    as HashRef[ResizeDiskRequest()];

declare 'ResizeInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResizeInstanceGroupManagerRequest'];

coerce 'ResizeInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResizeInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedResizeInstanceGroupManagerRequest',
    as ArrayRef[ResizeInstanceGroupManagerRequest()];

coerce 'RepeatedResizeInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResizeInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringResizeInstanceGroupManagerRequest',
    as HashRef[ResizeInstanceGroupManagerRequest()];

declare 'ResizeRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResizeRegionDiskRequest'];

coerce 'ResizeRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResizeRegionDiskRequest'->new($_) };

declare 'RepeatedResizeRegionDiskRequest',
    as ArrayRef[ResizeRegionDiskRequest()];

coerce 'RepeatedResizeRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResizeRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringResizeRegionDiskRequest',
    as HashRef[ResizeRegionDiskRequest()];

declare 'ResizeRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResizeRegionInstanceGroupManagerRequest'];

coerce 'ResizeRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResizeRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedResizeRegionInstanceGroupManagerRequest',
    as ArrayRef[ResizeRegionInstanceGroupManagerRequest()];

coerce 'RepeatedResizeRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResizeRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringResizeRegionInstanceGroupManagerRequest',
    as HashRef[ResizeRegionInstanceGroupManagerRequest()];

declare 'ResizeReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResizeReservationRequest'];

coerce 'ResizeReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResizeReservationRequest'->new($_) };

declare 'RepeatedResizeReservationRequest',
    as ArrayRef[ResizeReservationRequest()];

coerce 'RepeatedResizeReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResizeReservationRequest'->new($_) } @$_ ] };

declare 'MapStringResizeReservationRequest',
    as HashRef[ResizeReservationRequest()];

declare 'ResourceCommitment',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceCommitment'];

coerce 'ResourceCommitment',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceCommitment'->new($_) };

declare 'RepeatedResourceCommitment',
    as ArrayRef[ResourceCommitment()];

coerce 'RepeatedResourceCommitment',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceCommitment'->new($_) } @$_ ] };

declare 'MapStringResourceCommitment',
    as HashRef[ResourceCommitment()];

declare 'Type',
    as (Int | Str);

declare 'ResourceGroupReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceGroupReference'];

coerce 'ResourceGroupReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceGroupReference'->new($_) };

declare 'RepeatedResourceGroupReference',
    as ArrayRef[ResourceGroupReference()];

coerce 'RepeatedResourceGroupReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceGroupReference'->new($_) } @$_ ] };

declare 'MapStringResourceGroupReference',
    as HashRef[ResourceGroupReference()];

declare 'ResourcePoliciesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePoliciesScopedList'];

coerce 'ResourcePoliciesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePoliciesScopedList'->new($_) };

declare 'RepeatedResourcePoliciesScopedList',
    as ArrayRef[ResourcePoliciesScopedList()];

coerce 'RepeatedResourcePoliciesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePoliciesScopedList'->new($_) } @$_ ] };

declare 'MapStringResourcePoliciesScopedList',
    as HashRef[ResourcePoliciesScopedList()];

declare 'ResourcePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicy'];

coerce 'ResourcePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicy'->new($_) };

declare 'RepeatedResourcePolicy',
    as ArrayRef[ResourcePolicy()];

coerce 'RepeatedResourcePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicy'->new($_) } @$_ ] };

declare 'MapStringResourcePolicy',
    as HashRef[ResourcePolicy()];

declare 'Status',
    as (Int | Str);

declare 'ResourcePolicyAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyAggregatedList'];

coerce 'ResourcePolicyAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyAggregatedList'->new($_) };

declare 'RepeatedResourcePolicyAggregatedList',
    as ArrayRef[ResourcePolicyAggregatedList()];

coerce 'RepeatedResourcePolicyAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyAggregatedList'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyAggregatedList',
    as HashRef[ResourcePolicyAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'ResourcePolicyDailyCycle',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyDailyCycle'];

coerce 'ResourcePolicyDailyCycle',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyDailyCycle'->new($_) };

declare 'RepeatedResourcePolicyDailyCycle',
    as ArrayRef[ResourcePolicyDailyCycle()];

coerce 'RepeatedResourcePolicyDailyCycle',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyDailyCycle'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyDailyCycle',
    as HashRef[ResourcePolicyDailyCycle()];

declare 'ResourcePolicyDiskConsistencyGroupPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyDiskConsistencyGroupPolicy'];

coerce 'ResourcePolicyDiskConsistencyGroupPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyDiskConsistencyGroupPolicy'->new($_) };

declare 'RepeatedResourcePolicyDiskConsistencyGroupPolicy',
    as ArrayRef[ResourcePolicyDiskConsistencyGroupPolicy()];

coerce 'RepeatedResourcePolicyDiskConsistencyGroupPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyDiskConsistencyGroupPolicy'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyDiskConsistencyGroupPolicy',
    as HashRef[ResourcePolicyDiskConsistencyGroupPolicy()];

declare 'ResourcePolicyGroupPlacementPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyGroupPlacementPolicy'];

coerce 'ResourcePolicyGroupPlacementPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyGroupPlacementPolicy'->new($_) };

declare 'RepeatedResourcePolicyGroupPlacementPolicy',
    as ArrayRef[ResourcePolicyGroupPlacementPolicy()];

coerce 'RepeatedResourcePolicyGroupPlacementPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyGroupPlacementPolicy'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyGroupPlacementPolicy',
    as HashRef[ResourcePolicyGroupPlacementPolicy()];

declare 'AcceleratorTopologyMode',
    as (Int | Str);

declare 'Collocation',
    as (Int | Str);

declare 'ResourcePolicyHourlyCycle',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyHourlyCycle'];

coerce 'ResourcePolicyHourlyCycle',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyHourlyCycle'->new($_) };

declare 'RepeatedResourcePolicyHourlyCycle',
    as ArrayRef[ResourcePolicyHourlyCycle()];

coerce 'RepeatedResourcePolicyHourlyCycle',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyHourlyCycle'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyHourlyCycle',
    as HashRef[ResourcePolicyHourlyCycle()];

declare 'ResourcePolicyInstanceSchedulePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyInstanceSchedulePolicy'];

coerce 'ResourcePolicyInstanceSchedulePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyInstanceSchedulePolicy'->new($_) };

declare 'RepeatedResourcePolicyInstanceSchedulePolicy',
    as ArrayRef[ResourcePolicyInstanceSchedulePolicy()];

coerce 'RepeatedResourcePolicyInstanceSchedulePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyInstanceSchedulePolicy'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyInstanceSchedulePolicy',
    as HashRef[ResourcePolicyInstanceSchedulePolicy()];

declare 'ResourcePolicyInstanceSchedulePolicySchedule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyInstanceSchedulePolicySchedule'];

coerce 'ResourcePolicyInstanceSchedulePolicySchedule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyInstanceSchedulePolicySchedule'->new($_) };

declare 'RepeatedResourcePolicyInstanceSchedulePolicySchedule',
    as ArrayRef[ResourcePolicyInstanceSchedulePolicySchedule()];

coerce 'RepeatedResourcePolicyInstanceSchedulePolicySchedule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyInstanceSchedulePolicySchedule'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyInstanceSchedulePolicySchedule',
    as HashRef[ResourcePolicyInstanceSchedulePolicySchedule()];

declare 'ResourcePolicyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyList'];

coerce 'ResourcePolicyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyList'->new($_) };

declare 'RepeatedResourcePolicyList',
    as ArrayRef[ResourcePolicyList()];

coerce 'RepeatedResourcePolicyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyList'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyList',
    as HashRef[ResourcePolicyList()];

declare 'ResourcePolicyResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyResourceStatus'];

coerce 'ResourcePolicyResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyResourceStatus'->new($_) };

declare 'RepeatedResourcePolicyResourceStatus',
    as ArrayRef[ResourcePolicyResourceStatus()];

coerce 'RepeatedResourcePolicyResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyResourceStatus'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyResourceStatus',
    as HashRef[ResourcePolicyResourceStatus()];

declare 'ResourcePolicyResourceStatusInstanceSchedulePolicyStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyResourceStatusInstanceSchedulePolicyStatus'];

coerce 'ResourcePolicyResourceStatusInstanceSchedulePolicyStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyResourceStatusInstanceSchedulePolicyStatus'->new($_) };

declare 'RepeatedResourcePolicyResourceStatusInstanceSchedulePolicyStatus',
    as ArrayRef[ResourcePolicyResourceStatusInstanceSchedulePolicyStatus()];

coerce 'RepeatedResourcePolicyResourceStatusInstanceSchedulePolicyStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyResourceStatusInstanceSchedulePolicyStatus'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyResourceStatusInstanceSchedulePolicyStatus',
    as HashRef[ResourcePolicyResourceStatusInstanceSchedulePolicyStatus()];

declare 'ResourcePolicySnapshotSchedulePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicy'];

coerce 'ResourcePolicySnapshotSchedulePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicy'->new($_) };

declare 'RepeatedResourcePolicySnapshotSchedulePolicy',
    as ArrayRef[ResourcePolicySnapshotSchedulePolicy()];

coerce 'RepeatedResourcePolicySnapshotSchedulePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicy'->new($_) } @$_ ] };

declare 'MapStringResourcePolicySnapshotSchedulePolicy',
    as HashRef[ResourcePolicySnapshotSchedulePolicy()];

declare 'ResourcePolicySnapshotSchedulePolicyRetentionPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicyRetentionPolicy'];

coerce 'ResourcePolicySnapshotSchedulePolicyRetentionPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicyRetentionPolicy'->new($_) };

declare 'RepeatedResourcePolicySnapshotSchedulePolicyRetentionPolicy',
    as ArrayRef[ResourcePolicySnapshotSchedulePolicyRetentionPolicy()];

coerce 'RepeatedResourcePolicySnapshotSchedulePolicyRetentionPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicyRetentionPolicy'->new($_) } @$_ ] };

declare 'MapStringResourcePolicySnapshotSchedulePolicyRetentionPolicy',
    as HashRef[ResourcePolicySnapshotSchedulePolicyRetentionPolicy()];

declare 'OnSourceDiskDelete',
    as (Int | Str);

declare 'ResourcePolicySnapshotSchedulePolicySchedule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySchedule'];

coerce 'ResourcePolicySnapshotSchedulePolicySchedule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySchedule'->new($_) };

declare 'RepeatedResourcePolicySnapshotSchedulePolicySchedule',
    as ArrayRef[ResourcePolicySnapshotSchedulePolicySchedule()];

coerce 'RepeatedResourcePolicySnapshotSchedulePolicySchedule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySchedule'->new($_) } @$_ ] };

declare 'MapStringResourcePolicySnapshotSchedulePolicySchedule',
    as HashRef[ResourcePolicySnapshotSchedulePolicySchedule()];

declare 'ResourcePolicySnapshotSchedulePolicySnapshotProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySnapshotProperties'];

coerce 'ResourcePolicySnapshotSchedulePolicySnapshotProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySnapshotProperties'->new($_) };

declare 'RepeatedResourcePolicySnapshotSchedulePolicySnapshotProperties',
    as ArrayRef[ResourcePolicySnapshotSchedulePolicySnapshotProperties()];

coerce 'RepeatedResourcePolicySnapshotSchedulePolicySnapshotProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySnapshotProperties'->new($_) } @$_ ] };

declare 'MapStringResourcePolicySnapshotSchedulePolicySnapshotProperties',
    as HashRef[ResourcePolicySnapshotSchedulePolicySnapshotProperties()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySnapshotProperties::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySnapshotProperties::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicySnapshotSchedulePolicySnapshotProperties::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'ResourcePolicyWeeklyCycle',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyWeeklyCycle'];

coerce 'ResourcePolicyWeeklyCycle',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyWeeklyCycle'->new($_) };

declare 'RepeatedResourcePolicyWeeklyCycle',
    as ArrayRef[ResourcePolicyWeeklyCycle()];

coerce 'RepeatedResourcePolicyWeeklyCycle',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyWeeklyCycle'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyWeeklyCycle',
    as HashRef[ResourcePolicyWeeklyCycle()];

declare 'ResourcePolicyWeeklyCycleDayOfWeek',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyWeeklyCycleDayOfWeek'];

coerce 'ResourcePolicyWeeklyCycleDayOfWeek',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyWeeklyCycleDayOfWeek'->new($_) };

declare 'RepeatedResourcePolicyWeeklyCycleDayOfWeek',
    as ArrayRef[ResourcePolicyWeeklyCycleDayOfWeek()];

coerce 'RepeatedResourcePolicyWeeklyCycleDayOfWeek',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyWeeklyCycleDayOfWeek'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyWeeklyCycleDayOfWeek',
    as HashRef[ResourcePolicyWeeklyCycleDayOfWeek()];

declare 'Day',
    as (Int | Str);

declare 'ResourcePolicyWorkloadPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourcePolicyWorkloadPolicy'];

coerce 'ResourcePolicyWorkloadPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyWorkloadPolicy'->new($_) };

declare 'RepeatedResourcePolicyWorkloadPolicy',
    as ArrayRef[ResourcePolicyWorkloadPolicy()];

coerce 'RepeatedResourcePolicyWorkloadPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourcePolicyWorkloadPolicy'->new($_) } @$_ ] };

declare 'MapStringResourcePolicyWorkloadPolicy',
    as HashRef[ResourcePolicyWorkloadPolicy()];

declare 'AcceleratorTopologyMode',
    as (Int | Str);

declare 'MaxTopologyDistance',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'ResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceStatus'];

coerce 'ResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceStatus'->new($_) };

declare 'RepeatedResourceStatus',
    as ArrayRef[ResourceStatus()];

coerce 'RepeatedResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceStatus'->new($_) } @$_ ] };

declare 'MapStringResourceStatus',
    as HashRef[ResourceStatus()];

declare 'ResourceStatusEffectiveInstanceMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceStatusEffectiveInstanceMetadata'];

coerce 'ResourceStatusEffectiveInstanceMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceStatusEffectiveInstanceMetadata'->new($_) };

declare 'RepeatedResourceStatusEffectiveInstanceMetadata',
    as ArrayRef[ResourceStatusEffectiveInstanceMetadata()];

coerce 'RepeatedResourceStatusEffectiveInstanceMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceStatusEffectiveInstanceMetadata'->new($_) } @$_ ] };

declare 'MapStringResourceStatusEffectiveInstanceMetadata',
    as HashRef[ResourceStatusEffectiveInstanceMetadata()];

declare 'ResourceStatusPhysicalHostTopology',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopology'];

coerce 'ResourceStatusPhysicalHostTopology',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopology'->new($_) };

declare 'RepeatedResourceStatusPhysicalHostTopology',
    as ArrayRef[ResourceStatusPhysicalHostTopology()];

coerce 'RepeatedResourceStatusPhysicalHostTopology',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopology'->new($_) } @$_ ] };

declare 'MapStringResourceStatusPhysicalHostTopology',
    as HashRef[ResourceStatusPhysicalHostTopology()];

declare 'ResourceStatusPhysicalHostTopologyAdditionalAttributes',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopologyAdditionalAttributes'];

coerce 'ResourceStatusPhysicalHostTopologyAdditionalAttributes',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopologyAdditionalAttributes'->new($_) };

declare 'RepeatedResourceStatusPhysicalHostTopologyAdditionalAttributes',
    as ArrayRef[ResourceStatusPhysicalHostTopologyAdditionalAttributes()];

coerce 'RepeatedResourceStatusPhysicalHostTopologyAdditionalAttributes',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopologyAdditionalAttributes'->new($_) } @$_ ] };

declare 'MapStringResourceStatusPhysicalHostTopologyAdditionalAttributes',
    as HashRef[ResourceStatusPhysicalHostTopologyAdditionalAttributes()];

declare 'AcceleratorTopologyIdsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopologyAdditionalAttributes::AcceleratorTopologyIdsEntry'];

coerce 'AcceleratorTopologyIdsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopologyAdditionalAttributes::AcceleratorTopologyIdsEntry'->new($_) };

declare 'RepeatedAcceleratorTopologyIdsEntry',
    as ArrayRef[AcceleratorTopologyIdsEntry()];

coerce 'RepeatedAcceleratorTopologyIdsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceStatusPhysicalHostTopologyAdditionalAttributes::AcceleratorTopologyIdsEntry'->new($_) } @$_ ] };

declare 'MapStringAcceleratorTopologyIdsEntry',
    as HashRef[AcceleratorTopologyIdsEntry()];

declare 'ResourceStatusReservationConsumptionInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceStatusReservationConsumptionInfo'];

coerce 'ResourceStatusReservationConsumptionInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceStatusReservationConsumptionInfo'->new($_) };

declare 'RepeatedResourceStatusReservationConsumptionInfo',
    as ArrayRef[ResourceStatusReservationConsumptionInfo()];

coerce 'RepeatedResourceStatusReservationConsumptionInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceStatusReservationConsumptionInfo'->new($_) } @$_ ] };

declare 'MapStringResourceStatusReservationConsumptionInfo',
    as HashRef[ResourceStatusReservationConsumptionInfo()];

declare 'ResourceStatusScheduling',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResourceStatusScheduling'];

coerce 'ResourceStatusScheduling',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResourceStatusScheduling'->new($_) };

declare 'RepeatedResourceStatusScheduling',
    as ArrayRef[ResourceStatusScheduling()];

coerce 'RepeatedResourceStatusScheduling',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResourceStatusScheduling'->new($_) } @$_ ] };

declare 'MapStringResourceStatusScheduling',
    as HashRef[ResourceStatusScheduling()];

declare 'ResumeInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResumeInstanceRequest'];

coerce 'ResumeInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResumeInstanceRequest'->new($_) };

declare 'RepeatedResumeInstanceRequest',
    as ArrayRef[ResumeInstanceRequest()];

coerce 'RepeatedResumeInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResumeInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringResumeInstanceRequest',
    as HashRef[ResumeInstanceRequest()];

declare 'ResumeInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResumeInstancesInstanceGroupManagerRequest'];

coerce 'ResumeInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResumeInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedResumeInstancesInstanceGroupManagerRequest',
    as ArrayRef[ResumeInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedResumeInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResumeInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringResumeInstancesInstanceGroupManagerRequest',
    as HashRef[ResumeInstancesInstanceGroupManagerRequest()];

declare 'ResumeInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResumeInstancesRegionInstanceGroupManagerRequest'];

coerce 'ResumeInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResumeInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedResumeInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[ResumeInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedResumeInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResumeInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringResumeInstancesRegionInstanceGroupManagerRequest',
    as HashRef[ResumeInstancesRegionInstanceGroupManagerRequest()];

declare 'ResumeRolloutRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ResumeRolloutRequest'];

coerce 'ResumeRolloutRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ResumeRolloutRequest'->new($_) };

declare 'RepeatedResumeRolloutRequest',
    as ArrayRef[ResumeRolloutRequest()];

coerce 'RepeatedResumeRolloutRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ResumeRolloutRequest'->new($_) } @$_ ] };

declare 'MapStringResumeRolloutRequest',
    as HashRef[ResumeRolloutRequest()];

declare 'Rollout',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Rollout'];

coerce 'Rollout',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Rollout'->new($_) };

declare 'RepeatedRollout',
    as ArrayRef[Rollout()];

coerce 'RepeatedRollout',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Rollout'->new($_) } @$_ ] };

declare 'MapStringRollout',
    as HashRef[Rollout()];

declare 'State',
    as (Int | Str);

declare 'RolloutPlan',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlan'];

coerce 'RolloutPlan',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlan'->new($_) };

declare 'RepeatedRolloutPlan',
    as ArrayRef[RolloutPlan()];

coerce 'RepeatedRolloutPlan',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlan'->new($_) } @$_ ] };

declare 'MapStringRolloutPlan',
    as HashRef[RolloutPlan()];

declare 'LocationScope',
    as (Int | Str);

declare 'RolloutPlanWave',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWave'];

coerce 'RolloutPlanWave',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWave'->new($_) };

declare 'RepeatedRolloutPlanWave',
    as ArrayRef[RolloutPlanWave()];

coerce 'RepeatedRolloutPlanWave',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWave'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWave',
    as HashRef[RolloutPlanWave()];

declare 'RolloutPlanWaveOrchestrationOptions',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWaveOrchestrationOptions'];

coerce 'RolloutPlanWaveOrchestrationOptions',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveOrchestrationOptions'->new($_) };

declare 'RepeatedRolloutPlanWaveOrchestrationOptions',
    as ArrayRef[RolloutPlanWaveOrchestrationOptions()];

coerce 'RepeatedRolloutPlanWaveOrchestrationOptions',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveOrchestrationOptions'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWaveOrchestrationOptions',
    as HashRef[RolloutPlanWaveOrchestrationOptions()];

declare 'RolloutPlanWaveOrchestrationOptionsDelay',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWaveOrchestrationOptionsDelay'];

coerce 'RolloutPlanWaveOrchestrationOptionsDelay',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveOrchestrationOptionsDelay'->new($_) };

declare 'RepeatedRolloutPlanWaveOrchestrationOptionsDelay',
    as ArrayRef[RolloutPlanWaveOrchestrationOptionsDelay()];

coerce 'RepeatedRolloutPlanWaveOrchestrationOptionsDelay',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveOrchestrationOptionsDelay'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWaveOrchestrationOptionsDelay',
    as HashRef[RolloutPlanWaveOrchestrationOptionsDelay()];

declare 'Delimiter',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'RolloutPlanWaveSelector',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelector'];

coerce 'RolloutPlanWaveSelector',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelector'->new($_) };

declare 'RepeatedRolloutPlanWaveSelector',
    as ArrayRef[RolloutPlanWaveSelector()];

coerce 'RepeatedRolloutPlanWaveSelector',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelector'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWaveSelector',
    as HashRef[RolloutPlanWaveSelector()];

declare 'RolloutPlanWaveSelectorLocationSelector',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelectorLocationSelector'];

coerce 'RolloutPlanWaveSelectorLocationSelector',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelectorLocationSelector'->new($_) };

declare 'RepeatedRolloutPlanWaveSelectorLocationSelector',
    as ArrayRef[RolloutPlanWaveSelectorLocationSelector()];

coerce 'RepeatedRolloutPlanWaveSelectorLocationSelector',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelectorLocationSelector'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWaveSelectorLocationSelector',
    as HashRef[RolloutPlanWaveSelectorLocationSelector()];

declare 'RolloutPlanWaveSelectorResourceHierarchySelector',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelectorResourceHierarchySelector'];

coerce 'RolloutPlanWaveSelectorResourceHierarchySelector',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelectorResourceHierarchySelector'->new($_) };

declare 'RepeatedRolloutPlanWaveSelectorResourceHierarchySelector',
    as ArrayRef[RolloutPlanWaveSelectorResourceHierarchySelector()];

coerce 'RepeatedRolloutPlanWaveSelectorResourceHierarchySelector',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveSelectorResourceHierarchySelector'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWaveSelectorResourceHierarchySelector',
    as HashRef[RolloutPlanWaveSelectorResourceHierarchySelector()];

declare 'RolloutPlanWaveValidation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWaveValidation'];

coerce 'RolloutPlanWaveValidation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveValidation'->new($_) };

declare 'RepeatedRolloutPlanWaveValidation',
    as ArrayRef[RolloutPlanWaveValidation()];

coerce 'RepeatedRolloutPlanWaveValidation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveValidation'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWaveValidation',
    as HashRef[RolloutPlanWaveValidation()];

declare 'RolloutPlanWaveValidationTimeBasedValidationMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlanWaveValidationTimeBasedValidationMetadata'];

coerce 'RolloutPlanWaveValidationTimeBasedValidationMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveValidationTimeBasedValidationMetadata'->new($_) };

declare 'RepeatedRolloutPlanWaveValidationTimeBasedValidationMetadata',
    as ArrayRef[RolloutPlanWaveValidationTimeBasedValidationMetadata()];

coerce 'RepeatedRolloutPlanWaveValidationTimeBasedValidationMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlanWaveValidationTimeBasedValidationMetadata'->new($_) } @$_ ] };

declare 'MapStringRolloutPlanWaveValidationTimeBasedValidationMetadata',
    as HashRef[RolloutPlanWaveValidationTimeBasedValidationMetadata()];

declare 'RolloutPlansListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutPlansListResponse'];

coerce 'RolloutPlansListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutPlansListResponse'->new($_) };

declare 'RepeatedRolloutPlansListResponse',
    as ArrayRef[RolloutPlansListResponse()];

coerce 'RepeatedRolloutPlansListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutPlansListResponse'->new($_) } @$_ ] };

declare 'MapStringRolloutPlansListResponse',
    as HashRef[RolloutPlansListResponse()];

declare 'RolloutRolloutEntity',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutRolloutEntity'];

coerce 'RolloutRolloutEntity',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutRolloutEntity'->new($_) };

declare 'RepeatedRolloutRolloutEntity',
    as ArrayRef[RolloutRolloutEntity()];

coerce 'RepeatedRolloutRolloutEntity',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutRolloutEntity'->new($_) } @$_ ] };

declare 'MapStringRolloutRolloutEntity',
    as HashRef[RolloutRolloutEntity()];

declare 'RolloutRolloutEntityOrchestratedEntity',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutRolloutEntityOrchestratedEntity'];

coerce 'RolloutRolloutEntityOrchestratedEntity',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutRolloutEntityOrchestratedEntity'->new($_) };

declare 'RepeatedRolloutRolloutEntityOrchestratedEntity',
    as ArrayRef[RolloutRolloutEntityOrchestratedEntity()];

coerce 'RepeatedRolloutRolloutEntityOrchestratedEntity',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutRolloutEntityOrchestratedEntity'->new($_) } @$_ ] };

declare 'MapStringRolloutRolloutEntityOrchestratedEntity',
    as HashRef[RolloutRolloutEntityOrchestratedEntity()];

declare 'RolloutWaveDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutWaveDetails'];

coerce 'RolloutWaveDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetails'->new($_) };

declare 'RepeatedRolloutWaveDetails',
    as ArrayRef[RolloutWaveDetails()];

coerce 'RepeatedRolloutWaveDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetails'->new($_) } @$_ ] };

declare 'MapStringRolloutWaveDetails',
    as HashRef[RolloutWaveDetails()];

declare 'RolloutWaveDetailsOrchestratedWaveDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetails'];

coerce 'RolloutWaveDetailsOrchestratedWaveDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetails'->new($_) };

declare 'RepeatedRolloutWaveDetailsOrchestratedWaveDetails',
    as ArrayRef[RolloutWaveDetailsOrchestratedWaveDetails()];

coerce 'RepeatedRolloutWaveDetailsOrchestratedWaveDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetails'->new($_) } @$_ ] };

declare 'MapStringRolloutWaveDetailsOrchestratedWaveDetails',
    as HashRef[RolloutWaveDetailsOrchestratedWaveDetails()];

declare 'LocationStatusEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetails::LocationStatusEntry'];

coerce 'LocationStatusEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetails::LocationStatusEntry'->new($_) };

declare 'RepeatedLocationStatusEntry',
    as ArrayRef[LocationStatusEntry()];

coerce 'RepeatedLocationStatusEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetails::LocationStatusEntry'->new($_) } @$_ ] };

declare 'MapStringLocationStatusEntry',
    as HashRef[LocationStatusEntry()];

declare 'RolloutWaveDetailsOrchestratedWaveDetailsLocationStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetailsLocationStatus'];

coerce 'RolloutWaveDetailsOrchestratedWaveDetailsLocationStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetailsLocationStatus'->new($_) };

declare 'RepeatedRolloutWaveDetailsOrchestratedWaveDetailsLocationStatus',
    as ArrayRef[RolloutWaveDetailsOrchestratedWaveDetailsLocationStatus()];

coerce 'RepeatedRolloutWaveDetailsOrchestratedWaveDetailsLocationStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutWaveDetailsOrchestratedWaveDetailsLocationStatus'->new($_) } @$_ ] };

declare 'MapStringRolloutWaveDetailsOrchestratedWaveDetailsLocationStatus',
    as HashRef[RolloutWaveDetailsOrchestratedWaveDetailsLocationStatus()];

declare 'State',
    as (Int | Str);

declare 'RolloutsListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RolloutsListResponse'];

coerce 'RolloutsListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RolloutsListResponse'->new($_) };

declare 'RepeatedRolloutsListResponse',
    as ArrayRef[RolloutsListResponse()];

coerce 'RepeatedRolloutsListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RolloutsListResponse'->new($_) } @$_ ] };

declare 'MapStringRolloutsListResponse',
    as HashRef[RolloutsListResponse()];

declare 'Route',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Route'];

coerce 'Route',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Route'->new($_) };

declare 'RepeatedRoute',
    as ArrayRef[Route()];

coerce 'RepeatedRoute',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Route'->new($_) } @$_ ] };

declare 'MapStringRoute',
    as HashRef[Route()];

declare 'NextHopOrigin',
    as (Int | Str);

declare 'RouteStatus',
    as (Int | Str);

declare 'RouteType',
    as (Int | Str);

declare 'RouteAsPath',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouteAsPath'];

coerce 'RouteAsPath',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouteAsPath'->new($_) };

declare 'RepeatedRouteAsPath',
    as ArrayRef[RouteAsPath()];

coerce 'RepeatedRouteAsPath',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouteAsPath'->new($_) } @$_ ] };

declare 'MapStringRouteAsPath',
    as HashRef[RouteAsPath()];

declare 'PathSegmentType',
    as (Int | Str);

declare 'RouteList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouteList'];

coerce 'RouteList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouteList'->new($_) };

declare 'RepeatedRouteList',
    as ArrayRef[RouteList()];

coerce 'RepeatedRouteList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouteList'->new($_) } @$_ ] };

declare 'MapStringRouteList',
    as HashRef[RouteList()];

declare 'RouteParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouteParams'];

coerce 'RouteParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouteParams'->new($_) };

declare 'RepeatedRouteParams',
    as ArrayRef[RouteParams()];

coerce 'RepeatedRouteParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouteParams'->new($_) } @$_ ] };

declare 'MapStringRouteParams',
    as HashRef[RouteParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouteParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouteParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouteParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'RoutePolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutePolicy'];

coerce 'RoutePolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutePolicy'->new($_) };

declare 'RepeatedRoutePolicy',
    as ArrayRef[RoutePolicy()];

coerce 'RepeatedRoutePolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutePolicy'->new($_) } @$_ ] };

declare 'MapStringRoutePolicy',
    as HashRef[RoutePolicy()];

declare 'Type',
    as (Int | Str);

declare 'RoutePolicyPolicyTerm',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutePolicyPolicyTerm'];

coerce 'RoutePolicyPolicyTerm',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutePolicyPolicyTerm'->new($_) };

declare 'RepeatedRoutePolicyPolicyTerm',
    as ArrayRef[RoutePolicyPolicyTerm()];

coerce 'RepeatedRoutePolicyPolicyTerm',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutePolicyPolicyTerm'->new($_) } @$_ ] };

declare 'MapStringRoutePolicyPolicyTerm',
    as HashRef[RoutePolicyPolicyTerm()];

declare 'Router',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Router'];

coerce 'Router',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Router'->new($_) };

declare 'RepeatedRouter',
    as ArrayRef[Router()];

coerce 'RepeatedRouter',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Router'->new($_) } @$_ ] };

declare 'MapStringRouter',
    as HashRef[Router()];

declare 'RouterAdvertisedIpRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterAdvertisedIpRange'];

coerce 'RouterAdvertisedIpRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterAdvertisedIpRange'->new($_) };

declare 'RepeatedRouterAdvertisedIpRange',
    as ArrayRef[RouterAdvertisedIpRange()];

coerce 'RepeatedRouterAdvertisedIpRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterAdvertisedIpRange'->new($_) } @$_ ] };

declare 'MapStringRouterAdvertisedIpRange',
    as HashRef[RouterAdvertisedIpRange()];

declare 'RouterAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterAggregatedList'];

coerce 'RouterAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterAggregatedList'->new($_) };

declare 'RepeatedRouterAggregatedList',
    as ArrayRef[RouterAggregatedList()];

coerce 'RepeatedRouterAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterAggregatedList'->new($_) } @$_ ] };

declare 'MapStringRouterAggregatedList',
    as HashRef[RouterAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'RouterBgp',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterBgp'];

coerce 'RouterBgp',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterBgp'->new($_) };

declare 'RepeatedRouterBgp',
    as ArrayRef[RouterBgp()];

coerce 'RepeatedRouterBgp',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterBgp'->new($_) } @$_ ] };

declare 'MapStringRouterBgp',
    as HashRef[RouterBgp()];

declare 'AdvertiseMode',
    as (Int | Str);

declare 'AdvertisedGroups',
    as (Int | Str);

declare 'RouterBgpPeer',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterBgpPeer'];

coerce 'RouterBgpPeer',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterBgpPeer'->new($_) };

declare 'RepeatedRouterBgpPeer',
    as ArrayRef[RouterBgpPeer()];

coerce 'RepeatedRouterBgpPeer',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterBgpPeer'->new($_) } @$_ ] };

declare 'MapStringRouterBgpPeer',
    as HashRef[RouterBgpPeer()];

declare 'AdvertiseMode',
    as (Int | Str);

declare 'AdvertisedGroups',
    as (Int | Str);

declare 'Enable',
    as (Int | Str);

declare 'ManagementType',
    as (Int | Str);

declare 'RouterBgpPeerBfd',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterBgpPeerBfd'];

coerce 'RouterBgpPeerBfd',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterBgpPeerBfd'->new($_) };

declare 'RepeatedRouterBgpPeerBfd',
    as ArrayRef[RouterBgpPeerBfd()];

coerce 'RepeatedRouterBgpPeerBfd',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterBgpPeerBfd'->new($_) } @$_ ] };

declare 'MapStringRouterBgpPeerBfd',
    as HashRef[RouterBgpPeerBfd()];

declare 'SessionInitializationMode',
    as (Int | Str);

declare 'RouterBgpPeerCustomLearnedIpRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterBgpPeerCustomLearnedIpRange'];

coerce 'RouterBgpPeerCustomLearnedIpRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterBgpPeerCustomLearnedIpRange'->new($_) };

declare 'RepeatedRouterBgpPeerCustomLearnedIpRange',
    as ArrayRef[RouterBgpPeerCustomLearnedIpRange()];

coerce 'RepeatedRouterBgpPeerCustomLearnedIpRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterBgpPeerCustomLearnedIpRange'->new($_) } @$_ ] };

declare 'MapStringRouterBgpPeerCustomLearnedIpRange',
    as HashRef[RouterBgpPeerCustomLearnedIpRange()];

declare 'RouterInterface',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterInterface'];

coerce 'RouterInterface',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterInterface'->new($_) };

declare 'RepeatedRouterInterface',
    as ArrayRef[RouterInterface()];

coerce 'RepeatedRouterInterface',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterInterface'->new($_) } @$_ ] };

declare 'MapStringRouterInterface',
    as HashRef[RouterInterface()];

declare 'IpVersion',
    as (Int | Str);

declare 'ManagementType',
    as (Int | Str);

declare 'RouterList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterList'];

coerce 'RouterList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterList'->new($_) };

declare 'RepeatedRouterList',
    as ArrayRef[RouterList()];

coerce 'RepeatedRouterList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterList'->new($_) } @$_ ] };

declare 'MapStringRouterList',
    as HashRef[RouterList()];

declare 'RouterMd5AuthenticationKey',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterMd5AuthenticationKey'];

coerce 'RouterMd5AuthenticationKey',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterMd5AuthenticationKey'->new($_) };

declare 'RepeatedRouterMd5AuthenticationKey',
    as ArrayRef[RouterMd5AuthenticationKey()];

coerce 'RepeatedRouterMd5AuthenticationKey',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterMd5AuthenticationKey'->new($_) } @$_ ] };

declare 'MapStringRouterMd5AuthenticationKey',
    as HashRef[RouterMd5AuthenticationKey()];

declare 'RouterNat',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterNat'];

coerce 'RouterNat',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterNat'->new($_) };

declare 'RepeatedRouterNat',
    as ArrayRef[RouterNat()];

coerce 'RepeatedRouterNat',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterNat'->new($_) } @$_ ] };

declare 'MapStringRouterNat',
    as HashRef[RouterNat()];

declare 'AutoNetworkTier',
    as (Int | Str);

declare 'EndpointTypes',
    as (Int | Str);

declare 'NatIpAllocateOption',
    as (Int | Str);

declare 'SourceSubnetworkIpRangesToNat',
    as (Int | Str);

declare 'SourceSubnetworkIpRangesToNat64',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'RouterNatLogConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterNatLogConfig'];

coerce 'RouterNatLogConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterNatLogConfig'->new($_) };

declare 'RepeatedRouterNatLogConfig',
    as ArrayRef[RouterNatLogConfig()];

coerce 'RepeatedRouterNatLogConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterNatLogConfig'->new($_) } @$_ ] };

declare 'MapStringRouterNatLogConfig',
    as HashRef[RouterNatLogConfig()];

declare 'Filter',
    as (Int | Str);

declare 'RouterNatRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterNatRule'];

coerce 'RouterNatRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterNatRule'->new($_) };

declare 'RepeatedRouterNatRule',
    as ArrayRef[RouterNatRule()];

coerce 'RepeatedRouterNatRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterNatRule'->new($_) } @$_ ] };

declare 'MapStringRouterNatRule',
    as HashRef[RouterNatRule()];

declare 'RouterNatRuleAction',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterNatRuleAction'];

coerce 'RouterNatRuleAction',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterNatRuleAction'->new($_) };

declare 'RepeatedRouterNatRuleAction',
    as ArrayRef[RouterNatRuleAction()];

coerce 'RepeatedRouterNatRuleAction',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterNatRuleAction'->new($_) } @$_ ] };

declare 'MapStringRouterNatRuleAction',
    as HashRef[RouterNatRuleAction()];

declare 'RouterNatSubnetworkToNat',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterNatSubnetworkToNat'];

coerce 'RouterNatSubnetworkToNat',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterNatSubnetworkToNat'->new($_) };

declare 'RepeatedRouterNatSubnetworkToNat',
    as ArrayRef[RouterNatSubnetworkToNat()];

coerce 'RepeatedRouterNatSubnetworkToNat',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterNatSubnetworkToNat'->new($_) } @$_ ] };

declare 'MapStringRouterNatSubnetworkToNat',
    as HashRef[RouterNatSubnetworkToNat()];

declare 'SourceIpRangesToNat',
    as (Int | Str);

declare 'RouterNatSubnetworkToNat64',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterNatSubnetworkToNat64'];

coerce 'RouterNatSubnetworkToNat64',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterNatSubnetworkToNat64'->new($_) };

declare 'RepeatedRouterNatSubnetworkToNat64',
    as ArrayRef[RouterNatSubnetworkToNat64()];

coerce 'RepeatedRouterNatSubnetworkToNat64',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterNatSubnetworkToNat64'->new($_) } @$_ ] };

declare 'MapStringRouterNatSubnetworkToNat64',
    as HashRef[RouterNatSubnetworkToNat64()];

declare 'RouterParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterParams'];

coerce 'RouterParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterParams'->new($_) };

declare 'RepeatedRouterParams',
    as ArrayRef[RouterParams()];

coerce 'RepeatedRouterParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterParams'->new($_) } @$_ ] };

declare 'MapStringRouterParams',
    as HashRef[RouterParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'RouterStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterStatus'];

coerce 'RouterStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterStatus'->new($_) };

declare 'RepeatedRouterStatus',
    as ArrayRef[RouterStatus()];

coerce 'RepeatedRouterStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterStatus'->new($_) } @$_ ] };

declare 'MapStringRouterStatus',
    as HashRef[RouterStatus()];

declare 'RouterStatusBgpPeerStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterStatusBgpPeerStatus'];

coerce 'RouterStatusBgpPeerStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterStatusBgpPeerStatus'->new($_) };

declare 'RepeatedRouterStatusBgpPeerStatus',
    as ArrayRef[RouterStatusBgpPeerStatus()];

coerce 'RepeatedRouterStatusBgpPeerStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterStatusBgpPeerStatus'->new($_) } @$_ ] };

declare 'MapStringRouterStatusBgpPeerStatus',
    as HashRef[RouterStatusBgpPeerStatus()];

declare 'Status',
    as (Int | Str);

declare 'StatusReason',
    as (Int | Str);

declare 'RouterStatusNatStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterStatusNatStatus'];

coerce 'RouterStatusNatStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterStatusNatStatus'->new($_) };

declare 'RepeatedRouterStatusNatStatus',
    as ArrayRef[RouterStatusNatStatus()];

coerce 'RepeatedRouterStatusNatStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterStatusNatStatus'->new($_) } @$_ ] };

declare 'MapStringRouterStatusNatStatus',
    as HashRef[RouterStatusNatStatus()];

declare 'RouterStatusNatStatusNatRuleStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterStatusNatStatusNatRuleStatus'];

coerce 'RouterStatusNatStatusNatRuleStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterStatusNatStatusNatRuleStatus'->new($_) };

declare 'RepeatedRouterStatusNatStatusNatRuleStatus',
    as ArrayRef[RouterStatusNatStatusNatRuleStatus()];

coerce 'RepeatedRouterStatusNatStatusNatRuleStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterStatusNatStatusNatRuleStatus'->new($_) } @$_ ] };

declare 'MapStringRouterStatusNatStatusNatRuleStatus',
    as HashRef[RouterStatusNatStatusNatRuleStatus()];

declare 'RouterStatusResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RouterStatusResponse'];

coerce 'RouterStatusResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RouterStatusResponse'->new($_) };

declare 'RepeatedRouterStatusResponse',
    as ArrayRef[RouterStatusResponse()];

coerce 'RepeatedRouterStatusResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RouterStatusResponse'->new($_) } @$_ ] };

declare 'MapStringRouterStatusResponse',
    as HashRef[RouterStatusResponse()];

declare 'RoutersGetNamedSetResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutersGetNamedSetResponse'];

coerce 'RoutersGetNamedSetResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutersGetNamedSetResponse'->new($_) };

declare 'RepeatedRoutersGetNamedSetResponse',
    as ArrayRef[RoutersGetNamedSetResponse()];

coerce 'RepeatedRoutersGetNamedSetResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutersGetNamedSetResponse'->new($_) } @$_ ] };

declare 'MapStringRoutersGetNamedSetResponse',
    as HashRef[RoutersGetNamedSetResponse()];

declare 'RoutersGetRoutePolicyResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutersGetRoutePolicyResponse'];

coerce 'RoutersGetRoutePolicyResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutersGetRoutePolicyResponse'->new($_) };

declare 'RepeatedRoutersGetRoutePolicyResponse',
    as ArrayRef[RoutersGetRoutePolicyResponse()];

coerce 'RepeatedRoutersGetRoutePolicyResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutersGetRoutePolicyResponse'->new($_) } @$_ ] };

declare 'MapStringRoutersGetRoutePolicyResponse',
    as HashRef[RoutersGetRoutePolicyResponse()];

declare 'RoutersListBgpRoutes',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutersListBgpRoutes'];

coerce 'RoutersListBgpRoutes',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutersListBgpRoutes'->new($_) };

declare 'RepeatedRoutersListBgpRoutes',
    as ArrayRef[RoutersListBgpRoutes()];

coerce 'RepeatedRoutersListBgpRoutes',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutersListBgpRoutes'->new($_) } @$_ ] };

declare 'MapStringRoutersListBgpRoutes',
    as HashRef[RoutersListBgpRoutes()];

declare 'RoutersListNamedSets',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutersListNamedSets'];

coerce 'RoutersListNamedSets',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutersListNamedSets'->new($_) };

declare 'RepeatedRoutersListNamedSets',
    as ArrayRef[RoutersListNamedSets()];

coerce 'RepeatedRoutersListNamedSets',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutersListNamedSets'->new($_) } @$_ ] };

declare 'MapStringRoutersListNamedSets',
    as HashRef[RoutersListNamedSets()];

declare 'RoutersListRoutePolicies',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutersListRoutePolicies'];

coerce 'RoutersListRoutePolicies',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutersListRoutePolicies'->new($_) };

declare 'RepeatedRoutersListRoutePolicies',
    as ArrayRef[RoutersListRoutePolicies()];

coerce 'RepeatedRoutersListRoutePolicies',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutersListRoutePolicies'->new($_) } @$_ ] };

declare 'MapStringRoutersListRoutePolicies',
    as HashRef[RoutersListRoutePolicies()];

declare 'RoutersPreviewResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutersPreviewResponse'];

coerce 'RoutersPreviewResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutersPreviewResponse'->new($_) };

declare 'RepeatedRoutersPreviewResponse',
    as ArrayRef[RoutersPreviewResponse()];

coerce 'RepeatedRoutersPreviewResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutersPreviewResponse'->new($_) } @$_ ] };

declare 'MapStringRoutersPreviewResponse',
    as HashRef[RoutersPreviewResponse()];

declare 'RoutersScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::RoutersScopedList'];

coerce 'RoutersScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::RoutersScopedList'->new($_) };

declare 'RepeatedRoutersScopedList',
    as ArrayRef[RoutersScopedList()];

coerce 'RepeatedRoutersScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::RoutersScopedList'->new($_) } @$_ ] };

declare 'MapStringRoutersScopedList',
    as HashRef[RoutersScopedList()];

declare 'SSLHealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SSLHealthCheck'];

coerce 'SSLHealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SSLHealthCheck'->new($_) };

declare 'RepeatedSSLHealthCheck',
    as ArrayRef[SSLHealthCheck()];

coerce 'RepeatedSSLHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SSLHealthCheck'->new($_) } @$_ ] };

declare 'MapStringSSLHealthCheck',
    as HashRef[SSLHealthCheck()];

declare 'PortSpecification',
    as (Int | Str);

declare 'ProxyHeader',
    as (Int | Str);

declare 'SavedAttachedDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SavedAttachedDisk'];

coerce 'SavedAttachedDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SavedAttachedDisk'->new($_) };

declare 'RepeatedSavedAttachedDisk',
    as ArrayRef[SavedAttachedDisk()];

coerce 'RepeatedSavedAttachedDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SavedAttachedDisk'->new($_) } @$_ ] };

declare 'MapStringSavedAttachedDisk',
    as HashRef[SavedAttachedDisk()];

declare 'Interface',
    as (Int | Str);

declare 'Mode',
    as (Int | Str);

declare 'StorageBytesStatus',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'SavedDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SavedDisk'];

coerce 'SavedDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SavedDisk'->new($_) };

declare 'RepeatedSavedDisk',
    as ArrayRef[SavedDisk()];

coerce 'RepeatedSavedDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SavedDisk'->new($_) } @$_ ] };

declare 'MapStringSavedDisk',
    as HashRef[SavedDisk()];

declare 'Architecture',
    as (Int | Str);

declare 'StorageBytesStatus',
    as (Int | Str);

declare 'ScalingScheduleStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ScalingScheduleStatus'];

coerce 'ScalingScheduleStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ScalingScheduleStatus'->new($_) };

declare 'RepeatedScalingScheduleStatus',
    as ArrayRef[ScalingScheduleStatus()];

coerce 'RepeatedScalingScheduleStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ScalingScheduleStatus'->new($_) } @$_ ] };

declare 'MapStringScalingScheduleStatus',
    as HashRef[ScalingScheduleStatus()];

declare 'State',
    as (Int | Str);

declare 'Scheduling',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Scheduling'];

coerce 'Scheduling',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Scheduling'->new($_) };

declare 'RepeatedScheduling',
    as ArrayRef[Scheduling()];

coerce 'RepeatedScheduling',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Scheduling'->new($_) } @$_ ] };

declare 'MapStringScheduling',
    as HashRef[Scheduling()];

declare 'InstanceTerminationAction',
    as (Int | Str);

declare 'OnHostMaintenance',
    as (Int | Str);

declare 'ProvisioningModel',
    as (Int | Str);

declare 'SchedulingNodeAffinity',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SchedulingNodeAffinity'];

coerce 'SchedulingNodeAffinity',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SchedulingNodeAffinity'->new($_) };

declare 'RepeatedSchedulingNodeAffinity',
    as ArrayRef[SchedulingNodeAffinity()];

coerce 'RepeatedSchedulingNodeAffinity',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SchedulingNodeAffinity'->new($_) } @$_ ] };

declare 'MapStringSchedulingNodeAffinity',
    as HashRef[SchedulingNodeAffinity()];

declare 'Operator',
    as (Int | Str);

declare 'SchedulingOnInstanceStopAction',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SchedulingOnInstanceStopAction'];

coerce 'SchedulingOnInstanceStopAction',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SchedulingOnInstanceStopAction'->new($_) };

declare 'RepeatedSchedulingOnInstanceStopAction',
    as ArrayRef[SchedulingOnInstanceStopAction()];

coerce 'RepeatedSchedulingOnInstanceStopAction',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SchedulingOnInstanceStopAction'->new($_) } @$_ ] };

declare 'MapStringSchedulingOnInstanceStopAction',
    as HashRef[SchedulingOnInstanceStopAction()];

declare 'Screenshot',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Screenshot'];

coerce 'Screenshot',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Screenshot'->new($_) };

declare 'RepeatedScreenshot',
    as ArrayRef[Screenshot()];

coerce 'RepeatedScreenshot',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Screenshot'->new($_) } @$_ ] };

declare 'MapStringScreenshot',
    as HashRef[Screenshot()];

declare 'SecurityPoliciesAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPoliciesAggregatedList'];

coerce 'SecurityPoliciesAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesAggregatedList'->new($_) };

declare 'RepeatedSecurityPoliciesAggregatedList',
    as ArrayRef[SecurityPoliciesAggregatedList()];

coerce 'RepeatedSecurityPoliciesAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesAggregatedList'->new($_) } @$_ ] };

declare 'MapStringSecurityPoliciesAggregatedList',
    as HashRef[SecurityPoliciesAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPoliciesAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'SecurityPoliciesListPreconfiguredExpressionSetsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPoliciesListPreconfiguredExpressionSetsResponse'];

coerce 'SecurityPoliciesListPreconfiguredExpressionSetsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesListPreconfiguredExpressionSetsResponse'->new($_) };

declare 'RepeatedSecurityPoliciesListPreconfiguredExpressionSetsResponse',
    as ArrayRef[SecurityPoliciesListPreconfiguredExpressionSetsResponse()];

coerce 'RepeatedSecurityPoliciesListPreconfiguredExpressionSetsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesListPreconfiguredExpressionSetsResponse'->new($_) } @$_ ] };

declare 'MapStringSecurityPoliciesListPreconfiguredExpressionSetsResponse',
    as HashRef[SecurityPoliciesListPreconfiguredExpressionSetsResponse()];

declare 'SecurityPoliciesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPoliciesScopedList'];

coerce 'SecurityPoliciesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesScopedList'->new($_) };

declare 'RepeatedSecurityPoliciesScopedList',
    as ArrayRef[SecurityPoliciesScopedList()];

coerce 'RepeatedSecurityPoliciesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesScopedList'->new($_) } @$_ ] };

declare 'MapStringSecurityPoliciesScopedList',
    as HashRef[SecurityPoliciesScopedList()];

declare 'SecurityPoliciesWafConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPoliciesWafConfig'];

coerce 'SecurityPoliciesWafConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesWafConfig'->new($_) };

declare 'RepeatedSecurityPoliciesWafConfig',
    as ArrayRef[SecurityPoliciesWafConfig()];

coerce 'RepeatedSecurityPoliciesWafConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPoliciesWafConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPoliciesWafConfig',
    as HashRef[SecurityPoliciesWafConfig()];

declare 'SecurityPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicy'];

coerce 'SecurityPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicy'->new($_) };

declare 'RepeatedSecurityPolicy',
    as ArrayRef[SecurityPolicy()];

coerce 'RepeatedSecurityPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicy'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicy',
    as HashRef[SecurityPolicy()];

declare 'Type',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicy::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicy::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicy::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'SecurityPolicyAdaptiveProtectionConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfig'];

coerce 'SecurityPolicyAdaptiveProtectionConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfig'->new($_) };

declare 'RepeatedSecurityPolicyAdaptiveProtectionConfig',
    as ArrayRef[SecurityPolicyAdaptiveProtectionConfig()];

coerce 'RepeatedSecurityPolicyAdaptiveProtectionConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyAdaptiveProtectionConfig',
    as HashRef[SecurityPolicyAdaptiveProtectionConfig()];

declare 'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig'];

coerce 'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig'->new($_) };

declare 'RepeatedSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig',
    as ArrayRef[SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig()];

coerce 'RepeatedSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig',
    as HashRef[SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig()];

declare 'RuleVisibility',
    as (Int | Str);

declare 'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig'];

coerce 'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig'->new($_) };

declare 'RepeatedSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig',
    as ArrayRef[SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig()];

coerce 'RepeatedSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig',
    as HashRef[SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfig()];

declare 'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig'];

coerce 'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig'->new($_) };

declare 'RepeatedSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig',
    as ArrayRef[SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig()];

coerce 'RepeatedSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig',
    as HashRef[SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigThresholdConfigTrafficGranularityConfig()];

declare 'Type',
    as (Int | Str);

declare 'SecurityPolicyAdvancedOptionsConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyAdvancedOptionsConfig'];

coerce 'SecurityPolicyAdvancedOptionsConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdvancedOptionsConfig'->new($_) };

declare 'RepeatedSecurityPolicyAdvancedOptionsConfig',
    as ArrayRef[SecurityPolicyAdvancedOptionsConfig()];

coerce 'RepeatedSecurityPolicyAdvancedOptionsConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdvancedOptionsConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyAdvancedOptionsConfig',
    as HashRef[SecurityPolicyAdvancedOptionsConfig()];

declare 'JsonParsing',
    as (Int | Str);

declare 'LogLevel',
    as (Int | Str);

declare 'SecurityPolicyAdvancedOptionsConfigJsonCustomConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyAdvancedOptionsConfigJsonCustomConfig'];

coerce 'SecurityPolicyAdvancedOptionsConfigJsonCustomConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdvancedOptionsConfigJsonCustomConfig'->new($_) };

declare 'RepeatedSecurityPolicyAdvancedOptionsConfigJsonCustomConfig',
    as ArrayRef[SecurityPolicyAdvancedOptionsConfigJsonCustomConfig()];

coerce 'RepeatedSecurityPolicyAdvancedOptionsConfigJsonCustomConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAdvancedOptionsConfigJsonCustomConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyAdvancedOptionsConfigJsonCustomConfig',
    as HashRef[SecurityPolicyAdvancedOptionsConfigJsonCustomConfig()];

declare 'SecurityPolicyAssociation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyAssociation'];

coerce 'SecurityPolicyAssociation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAssociation'->new($_) };

declare 'RepeatedSecurityPolicyAssociation',
    as ArrayRef[SecurityPolicyAssociation()];

coerce 'RepeatedSecurityPolicyAssociation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyAssociation'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyAssociation',
    as HashRef[SecurityPolicyAssociation()];

declare 'SecurityPolicyDdosProtectionConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyDdosProtectionConfig'];

coerce 'SecurityPolicyDdosProtectionConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyDdosProtectionConfig'->new($_) };

declare 'RepeatedSecurityPolicyDdosProtectionConfig',
    as ArrayRef[SecurityPolicyDdosProtectionConfig()];

coerce 'RepeatedSecurityPolicyDdosProtectionConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyDdosProtectionConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyDdosProtectionConfig',
    as HashRef[SecurityPolicyDdosProtectionConfig()];

declare 'DdosAdaptiveProtection',
    as (Int | Str);

declare 'DdosProtection',
    as (Int | Str);

declare 'SecurityPolicyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyList'];

coerce 'SecurityPolicyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyList'->new($_) };

declare 'RepeatedSecurityPolicyList',
    as ArrayRef[SecurityPolicyList()];

coerce 'RepeatedSecurityPolicyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyList'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyList',
    as HashRef[SecurityPolicyList()];

declare 'SecurityPolicyRecaptchaOptionsConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRecaptchaOptionsConfig'];

coerce 'SecurityPolicyRecaptchaOptionsConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRecaptchaOptionsConfig'->new($_) };

declare 'RepeatedSecurityPolicyRecaptchaOptionsConfig',
    as ArrayRef[SecurityPolicyRecaptchaOptionsConfig()];

coerce 'RepeatedSecurityPolicyRecaptchaOptionsConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRecaptchaOptionsConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRecaptchaOptionsConfig',
    as HashRef[SecurityPolicyRecaptchaOptionsConfig()];

declare 'SecurityPolicyReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyReference'];

coerce 'SecurityPolicyReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyReference'->new($_) };

declare 'RepeatedSecurityPolicyReference',
    as ArrayRef[SecurityPolicyReference()];

coerce 'RepeatedSecurityPolicyReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyReference'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyReference',
    as HashRef[SecurityPolicyReference()];

declare 'SecurityPolicyRule',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRule'];

coerce 'SecurityPolicyRule',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRule'->new($_) };

declare 'RepeatedSecurityPolicyRule',
    as ArrayRef[SecurityPolicyRule()];

coerce 'RepeatedSecurityPolicyRule',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRule'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRule',
    as HashRef[SecurityPolicyRule()];

declare 'SecurityPolicyRuleHttpHeaderAction',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleHttpHeaderAction'];

coerce 'SecurityPolicyRuleHttpHeaderAction',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleHttpHeaderAction'->new($_) };

declare 'RepeatedSecurityPolicyRuleHttpHeaderAction',
    as ArrayRef[SecurityPolicyRuleHttpHeaderAction()];

coerce 'RepeatedSecurityPolicyRuleHttpHeaderAction',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleHttpHeaderAction'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleHttpHeaderAction',
    as HashRef[SecurityPolicyRuleHttpHeaderAction()];

declare 'SecurityPolicyRuleHttpHeaderActionHttpHeaderOption',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleHttpHeaderActionHttpHeaderOption'];

coerce 'SecurityPolicyRuleHttpHeaderActionHttpHeaderOption',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleHttpHeaderActionHttpHeaderOption'->new($_) };

declare 'RepeatedSecurityPolicyRuleHttpHeaderActionHttpHeaderOption',
    as ArrayRef[SecurityPolicyRuleHttpHeaderActionHttpHeaderOption()];

coerce 'RepeatedSecurityPolicyRuleHttpHeaderActionHttpHeaderOption',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleHttpHeaderActionHttpHeaderOption'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleHttpHeaderActionHttpHeaderOption',
    as HashRef[SecurityPolicyRuleHttpHeaderActionHttpHeaderOption()];

declare 'SecurityPolicyRuleMatcher',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcher'];

coerce 'SecurityPolicyRuleMatcher',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcher'->new($_) };

declare 'RepeatedSecurityPolicyRuleMatcher',
    as ArrayRef[SecurityPolicyRuleMatcher()];

coerce 'RepeatedSecurityPolicyRuleMatcher',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcher'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleMatcher',
    as HashRef[SecurityPolicyRuleMatcher()];

declare 'VersionedExpr',
    as (Int | Str);

declare 'SecurityPolicyRuleMatcherConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherConfig'];

coerce 'SecurityPolicyRuleMatcherConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherConfig'->new($_) };

declare 'RepeatedSecurityPolicyRuleMatcherConfig',
    as ArrayRef[SecurityPolicyRuleMatcherConfig()];

coerce 'RepeatedSecurityPolicyRuleMatcherConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleMatcherConfig',
    as HashRef[SecurityPolicyRuleMatcherConfig()];

declare 'SecurityPolicyRuleMatcherExprOptions',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherExprOptions'];

coerce 'SecurityPolicyRuleMatcherExprOptions',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherExprOptions'->new($_) };

declare 'RepeatedSecurityPolicyRuleMatcherExprOptions',
    as ArrayRef[SecurityPolicyRuleMatcherExprOptions()];

coerce 'RepeatedSecurityPolicyRuleMatcherExprOptions',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherExprOptions'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleMatcherExprOptions',
    as HashRef[SecurityPolicyRuleMatcherExprOptions()];

declare 'SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions'];

coerce 'SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions'->new($_) };

declare 'RepeatedSecurityPolicyRuleMatcherExprOptionsRecaptchaOptions',
    as ArrayRef[SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions()];

coerce 'RepeatedSecurityPolicyRuleMatcherExprOptionsRecaptchaOptions',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleMatcherExprOptionsRecaptchaOptions',
    as HashRef[SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions()];

declare 'SecurityPolicyRuleNetworkMatcher',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleNetworkMatcher'];

coerce 'SecurityPolicyRuleNetworkMatcher',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleNetworkMatcher'->new($_) };

declare 'RepeatedSecurityPolicyRuleNetworkMatcher',
    as ArrayRef[SecurityPolicyRuleNetworkMatcher()];

coerce 'RepeatedSecurityPolicyRuleNetworkMatcher',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleNetworkMatcher'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleNetworkMatcher',
    as HashRef[SecurityPolicyRuleNetworkMatcher()];

declare 'SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch'];

coerce 'SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch'->new($_) };

declare 'RepeatedSecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch',
    as ArrayRef[SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch()];

coerce 'RepeatedSecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch',
    as HashRef[SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch()];

declare 'SecurityPolicyRulePreconfiguredWafConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfig'];

coerce 'SecurityPolicyRulePreconfiguredWafConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfig'->new($_) };

declare 'RepeatedSecurityPolicyRulePreconfiguredWafConfig',
    as ArrayRef[SecurityPolicyRulePreconfiguredWafConfig()];

coerce 'RepeatedSecurityPolicyRulePreconfiguredWafConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRulePreconfiguredWafConfig',
    as HashRef[SecurityPolicyRulePreconfiguredWafConfig()];

declare 'SecurityPolicyRulePreconfiguredWafConfigExclusion',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfigExclusion'];

coerce 'SecurityPolicyRulePreconfiguredWafConfigExclusion',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfigExclusion'->new($_) };

declare 'RepeatedSecurityPolicyRulePreconfiguredWafConfigExclusion',
    as ArrayRef[SecurityPolicyRulePreconfiguredWafConfigExclusion()];

coerce 'RepeatedSecurityPolicyRulePreconfiguredWafConfigExclusion',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfigExclusion'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRulePreconfiguredWafConfigExclusion',
    as HashRef[SecurityPolicyRulePreconfiguredWafConfigExclusion()];

declare 'SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams'];

coerce 'SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams'->new($_) };

declare 'RepeatedSecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams',
    as ArrayRef[SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams()];

coerce 'RepeatedSecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams',
    as HashRef[SecurityPolicyRulePreconfiguredWafConfigExclusionFieldParams()];

declare 'Op',
    as (Int | Str);

declare 'SecurityPolicyRuleRateLimitOptions',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptions'];

coerce 'SecurityPolicyRuleRateLimitOptions',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptions'->new($_) };

declare 'RepeatedSecurityPolicyRuleRateLimitOptions',
    as ArrayRef[SecurityPolicyRuleRateLimitOptions()];

coerce 'RepeatedSecurityPolicyRuleRateLimitOptions',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptions'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleRateLimitOptions',
    as HashRef[SecurityPolicyRuleRateLimitOptions()];

declare 'EnforceOnKey',
    as (Int | Str);

declare 'SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig'];

coerce 'SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig'->new($_) };

declare 'RepeatedSecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig',
    as ArrayRef[SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig()];

coerce 'RepeatedSecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig',
    as HashRef[SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig()];

declare 'EnforceOnKeyType',
    as (Int | Str);

declare 'SecurityPolicyRuleRateLimitOptionsThreshold',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptionsThreshold'];

coerce 'SecurityPolicyRuleRateLimitOptionsThreshold',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptionsThreshold'->new($_) };

declare 'RepeatedSecurityPolicyRuleRateLimitOptionsThreshold',
    as ArrayRef[SecurityPolicyRuleRateLimitOptionsThreshold()];

coerce 'RepeatedSecurityPolicyRuleRateLimitOptionsThreshold',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRateLimitOptionsThreshold'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleRateLimitOptionsThreshold',
    as HashRef[SecurityPolicyRuleRateLimitOptionsThreshold()];

declare 'SecurityPolicyRuleRedirectOptions',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRedirectOptions'];

coerce 'SecurityPolicyRuleRedirectOptions',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRedirectOptions'->new($_) };

declare 'RepeatedSecurityPolicyRuleRedirectOptions',
    as ArrayRef[SecurityPolicyRuleRedirectOptions()];

coerce 'RepeatedSecurityPolicyRuleRedirectOptions',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyRuleRedirectOptions'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyRuleRedirectOptions',
    as HashRef[SecurityPolicyRuleRedirectOptions()];

declare 'Type',
    as (Int | Str);

declare 'SecurityPolicyUserDefinedField',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecurityPolicyUserDefinedField'];

coerce 'SecurityPolicyUserDefinedField',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyUserDefinedField'->new($_) };

declare 'RepeatedSecurityPolicyUserDefinedField',
    as ArrayRef[SecurityPolicyUserDefinedField()];

coerce 'RepeatedSecurityPolicyUserDefinedField',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecurityPolicyUserDefinedField'->new($_) } @$_ ] };

declare 'MapStringSecurityPolicyUserDefinedField',
    as HashRef[SecurityPolicyUserDefinedField()];

declare 'Base',
    as (Int | Str);

declare 'SecuritySettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SecuritySettings'];

coerce 'SecuritySettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SecuritySettings'->new($_) };

declare 'RepeatedSecuritySettings',
    as ArrayRef[SecuritySettings()];

coerce 'RepeatedSecuritySettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SecuritySettings'->new($_) } @$_ ] };

declare 'MapStringSecuritySettings',
    as HashRef[SecuritySettings()];

declare 'SendDiagnosticInterruptInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SendDiagnosticInterruptInstanceRequest'];

coerce 'SendDiagnosticInterruptInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SendDiagnosticInterruptInstanceRequest'->new($_) };

declare 'RepeatedSendDiagnosticInterruptInstanceRequest',
    as ArrayRef[SendDiagnosticInterruptInstanceRequest()];

coerce 'RepeatedSendDiagnosticInterruptInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SendDiagnosticInterruptInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSendDiagnosticInterruptInstanceRequest',
    as HashRef[SendDiagnosticInterruptInstanceRequest()];

declare 'SendDiagnosticInterruptInstanceResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SendDiagnosticInterruptInstanceResponse'];

coerce 'SendDiagnosticInterruptInstanceResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SendDiagnosticInterruptInstanceResponse'->new($_) };

declare 'RepeatedSendDiagnosticInterruptInstanceResponse',
    as ArrayRef[SendDiagnosticInterruptInstanceResponse()];

coerce 'RepeatedSendDiagnosticInterruptInstanceResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SendDiagnosticInterruptInstanceResponse'->new($_) } @$_ ] };

declare 'MapStringSendDiagnosticInterruptInstanceResponse',
    as HashRef[SendDiagnosticInterruptInstanceResponse()];

declare 'SerialPortOutput',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SerialPortOutput'];

coerce 'SerialPortOutput',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SerialPortOutput'->new($_) };

declare 'RepeatedSerialPortOutput',
    as ArrayRef[SerialPortOutput()];

coerce 'RepeatedSerialPortOutput',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SerialPortOutput'->new($_) } @$_ ] };

declare 'MapStringSerialPortOutput',
    as HashRef[SerialPortOutput()];

declare 'ServerBinding',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServerBinding'];

coerce 'ServerBinding',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServerBinding'->new($_) };

declare 'RepeatedServerBinding',
    as ArrayRef[ServerBinding()];

coerce 'RepeatedServerBinding',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServerBinding'->new($_) } @$_ ] };

declare 'MapStringServerBinding',
    as HashRef[ServerBinding()];

declare 'Type',
    as (Int | Str);

declare 'ServiceAccount',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAccount'];

coerce 'ServiceAccount',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAccount'->new($_) };

declare 'RepeatedServiceAccount',
    as ArrayRef[ServiceAccount()];

coerce 'RepeatedServiceAccount',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAccount'->new($_) } @$_ ] };

declare 'MapStringServiceAccount',
    as HashRef[ServiceAccount()];

declare 'ServiceAttachment',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachment'];

coerce 'ServiceAttachment',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachment'->new($_) };

declare 'RepeatedServiceAttachment',
    as ArrayRef[ServiceAttachment()];

coerce 'RepeatedServiceAttachment',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachment'->new($_) } @$_ ] };

declare 'MapStringServiceAttachment',
    as HashRef[ServiceAttachment()];

declare 'ConnectionPreference',
    as (Int | Str);

declare 'MetadataEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachment::MetadataEntry'];

coerce 'MetadataEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachment::MetadataEntry'->new($_) };

declare 'RepeatedMetadataEntry',
    as ArrayRef[MetadataEntry()];

coerce 'RepeatedMetadataEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachment::MetadataEntry'->new($_) } @$_ ] };

declare 'MapStringMetadataEntry',
    as HashRef[MetadataEntry()];

declare 'ServiceAttachmentAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachmentAggregatedList'];

coerce 'ServiceAttachmentAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentAggregatedList'->new($_) };

declare 'RepeatedServiceAttachmentAggregatedList',
    as ArrayRef[ServiceAttachmentAggregatedList()];

coerce 'RepeatedServiceAttachmentAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentAggregatedList'->new($_) } @$_ ] };

declare 'MapStringServiceAttachmentAggregatedList',
    as HashRef[ServiceAttachmentAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachmentAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'ServiceAttachmentConnectedEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachmentConnectedEndpoint'];

coerce 'ServiceAttachmentConnectedEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentConnectedEndpoint'->new($_) };

declare 'RepeatedServiceAttachmentConnectedEndpoint',
    as ArrayRef[ServiceAttachmentConnectedEndpoint()];

coerce 'RepeatedServiceAttachmentConnectedEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentConnectedEndpoint'->new($_) } @$_ ] };

declare 'MapStringServiceAttachmentConnectedEndpoint',
    as HashRef[ServiceAttachmentConnectedEndpoint()];

declare 'Status',
    as (Int | Str);

declare 'ServiceAttachmentConsumerProjectLimit',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachmentConsumerProjectLimit'];

coerce 'ServiceAttachmentConsumerProjectLimit',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentConsumerProjectLimit'->new($_) };

declare 'RepeatedServiceAttachmentConsumerProjectLimit',
    as ArrayRef[ServiceAttachmentConsumerProjectLimit()];

coerce 'RepeatedServiceAttachmentConsumerProjectLimit',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentConsumerProjectLimit'->new($_) } @$_ ] };

declare 'MapStringServiceAttachmentConsumerProjectLimit',
    as HashRef[ServiceAttachmentConsumerProjectLimit()];

declare 'ServiceAttachmentList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachmentList'];

coerce 'ServiceAttachmentList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentList'->new($_) };

declare 'RepeatedServiceAttachmentList',
    as ArrayRef[ServiceAttachmentList()];

coerce 'RepeatedServiceAttachmentList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentList'->new($_) } @$_ ] };

declare 'MapStringServiceAttachmentList',
    as HashRef[ServiceAttachmentList()];

declare 'ServiceAttachmentsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ServiceAttachmentsScopedList'];

coerce 'ServiceAttachmentsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentsScopedList'->new($_) };

declare 'RepeatedServiceAttachmentsScopedList',
    as ArrayRef[ServiceAttachmentsScopedList()];

coerce 'RepeatedServiceAttachmentsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ServiceAttachmentsScopedList'->new($_) } @$_ ] };

declare 'MapStringServiceAttachmentsScopedList',
    as HashRef[ServiceAttachmentsScopedList()];

declare 'SetBackendServiceTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetBackendServiceTargetSslProxyRequest'];

coerce 'SetBackendServiceTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetBackendServiceTargetSslProxyRequest'->new($_) };

declare 'RepeatedSetBackendServiceTargetSslProxyRequest',
    as ArrayRef[SetBackendServiceTargetSslProxyRequest()];

coerce 'RepeatedSetBackendServiceTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetBackendServiceTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetBackendServiceTargetSslProxyRequest',
    as HashRef[SetBackendServiceTargetSslProxyRequest()];

declare 'SetBackendServiceTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetBackendServiceTargetTcpProxyRequest'];

coerce 'SetBackendServiceTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetBackendServiceTargetTcpProxyRequest'->new($_) };

declare 'RepeatedSetBackendServiceTargetTcpProxyRequest',
    as ArrayRef[SetBackendServiceTargetTcpProxyRequest()];

coerce 'RepeatedSetBackendServiceTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetBackendServiceTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetBackendServiceTargetTcpProxyRequest',
    as HashRef[SetBackendServiceTargetTcpProxyRequest()];

declare 'SetBackupTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetBackupTargetPoolRequest'];

coerce 'SetBackupTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetBackupTargetPoolRequest'->new($_) };

declare 'RepeatedSetBackupTargetPoolRequest',
    as ArrayRef[SetBackupTargetPoolRequest()];

coerce 'RepeatedSetBackupTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetBackupTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringSetBackupTargetPoolRequest',
    as HashRef[SetBackupTargetPoolRequest()];

declare 'SetCertificateMapTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetCertificateMapTargetHttpsProxyRequest'];

coerce 'SetCertificateMapTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetCertificateMapTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedSetCertificateMapTargetHttpsProxyRequest',
    as ArrayRef[SetCertificateMapTargetHttpsProxyRequest()];

coerce 'RepeatedSetCertificateMapTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetCertificateMapTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetCertificateMapTargetHttpsProxyRequest',
    as HashRef[SetCertificateMapTargetHttpsProxyRequest()];

declare 'SetCertificateMapTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetCertificateMapTargetSslProxyRequest'];

coerce 'SetCertificateMapTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetCertificateMapTargetSslProxyRequest'->new($_) };

declare 'RepeatedSetCertificateMapTargetSslProxyRequest',
    as ArrayRef[SetCertificateMapTargetSslProxyRequest()];

coerce 'RepeatedSetCertificateMapTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetCertificateMapTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetCertificateMapTargetSslProxyRequest',
    as HashRef[SetCertificateMapTargetSslProxyRequest()];

declare 'SetCloudArmorTierProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetCloudArmorTierProjectRequest'];

coerce 'SetCloudArmorTierProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetCloudArmorTierProjectRequest'->new($_) };

declare 'RepeatedSetCloudArmorTierProjectRequest',
    as ArrayRef[SetCloudArmorTierProjectRequest()];

coerce 'RepeatedSetCloudArmorTierProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetCloudArmorTierProjectRequest'->new($_) } @$_ ] };

declare 'MapStringSetCloudArmorTierProjectRequest',
    as HashRef[SetCloudArmorTierProjectRequest()];

declare 'SetCommonInstanceMetadataOperationMetadata',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadata'];

coerce 'SetCommonInstanceMetadataOperationMetadata',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadata'->new($_) };

declare 'RepeatedSetCommonInstanceMetadataOperationMetadata',
    as ArrayRef[SetCommonInstanceMetadataOperationMetadata()];

coerce 'RepeatedSetCommonInstanceMetadataOperationMetadata',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadata'->new($_) } @$_ ] };

declare 'MapStringSetCommonInstanceMetadataOperationMetadata',
    as HashRef[SetCommonInstanceMetadataOperationMetadata()];

declare 'PerLocationOperationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadata::PerLocationOperationsEntry'];

coerce 'PerLocationOperationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadata::PerLocationOperationsEntry'->new($_) };

declare 'RepeatedPerLocationOperationsEntry',
    as ArrayRef[PerLocationOperationsEntry()];

coerce 'RepeatedPerLocationOperationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadata::PerLocationOperationsEntry'->new($_) } @$_ ] };

declare 'MapStringPerLocationOperationsEntry',
    as HashRef[PerLocationOperationsEntry()];

declare 'SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo'];

coerce 'SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo'->new($_) };

declare 'RepeatedSetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo',
    as ArrayRef[SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo()];

coerce 'RepeatedSetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo'->new($_) } @$_ ] };

declare 'MapStringSetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo',
    as HashRef[SetCommonInstanceMetadataOperationMetadataPerLocationOperationInfo()];

declare 'State',
    as (Int | Str);

declare 'SetCommonInstanceMetadataProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataProjectRequest'];

coerce 'SetCommonInstanceMetadataProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataProjectRequest'->new($_) };

declare 'RepeatedSetCommonInstanceMetadataProjectRequest',
    as ArrayRef[SetCommonInstanceMetadataProjectRequest()];

coerce 'RepeatedSetCommonInstanceMetadataProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetCommonInstanceMetadataProjectRequest'->new($_) } @$_ ] };

declare 'MapStringSetCommonInstanceMetadataProjectRequest',
    as HashRef[SetCommonInstanceMetadataProjectRequest()];

declare 'SetDefaultNetworkTierProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetDefaultNetworkTierProjectRequest'];

coerce 'SetDefaultNetworkTierProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetDefaultNetworkTierProjectRequest'->new($_) };

declare 'RepeatedSetDefaultNetworkTierProjectRequest',
    as ArrayRef[SetDefaultNetworkTierProjectRequest()];

coerce 'RepeatedSetDefaultNetworkTierProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetDefaultNetworkTierProjectRequest'->new($_) } @$_ ] };

declare 'MapStringSetDefaultNetworkTierProjectRequest',
    as HashRef[SetDefaultNetworkTierProjectRequest()];

declare 'SetDeletionProtectionInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetDeletionProtectionInstanceRequest'];

coerce 'SetDeletionProtectionInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetDeletionProtectionInstanceRequest'->new($_) };

declare 'RepeatedSetDeletionProtectionInstanceRequest',
    as ArrayRef[SetDeletionProtectionInstanceRequest()];

coerce 'RepeatedSetDeletionProtectionInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetDeletionProtectionInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetDeletionProtectionInstanceRequest',
    as HashRef[SetDeletionProtectionInstanceRequest()];

declare 'SetDiskAutoDeleteInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetDiskAutoDeleteInstanceRequest'];

coerce 'SetDiskAutoDeleteInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetDiskAutoDeleteInstanceRequest'->new($_) };

declare 'RepeatedSetDiskAutoDeleteInstanceRequest',
    as ArrayRef[SetDiskAutoDeleteInstanceRequest()];

coerce 'RepeatedSetDiskAutoDeleteInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetDiskAutoDeleteInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetDiskAutoDeleteInstanceRequest',
    as HashRef[SetDiskAutoDeleteInstanceRequest()];

declare 'SetEdgeSecurityPolicyBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetEdgeSecurityPolicyBackendBucketRequest'];

coerce 'SetEdgeSecurityPolicyBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetEdgeSecurityPolicyBackendBucketRequest'->new($_) };

declare 'RepeatedSetEdgeSecurityPolicyBackendBucketRequest',
    as ArrayRef[SetEdgeSecurityPolicyBackendBucketRequest()];

coerce 'RepeatedSetEdgeSecurityPolicyBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetEdgeSecurityPolicyBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringSetEdgeSecurityPolicyBackendBucketRequest',
    as HashRef[SetEdgeSecurityPolicyBackendBucketRequest()];

declare 'SetEdgeSecurityPolicyBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetEdgeSecurityPolicyBackendServiceRequest'];

coerce 'SetEdgeSecurityPolicyBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetEdgeSecurityPolicyBackendServiceRequest'->new($_) };

declare 'RepeatedSetEdgeSecurityPolicyBackendServiceRequest',
    as ArrayRef[SetEdgeSecurityPolicyBackendServiceRequest()];

coerce 'RepeatedSetEdgeSecurityPolicyBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetEdgeSecurityPolicyBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringSetEdgeSecurityPolicyBackendServiceRequest',
    as HashRef[SetEdgeSecurityPolicyBackendServiceRequest()];

declare 'SetIamPolicyBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyBackendBucketRequest'];

coerce 'SetIamPolicyBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyBackendBucketRequest'->new($_) };

declare 'RepeatedSetIamPolicyBackendBucketRequest',
    as ArrayRef[SetIamPolicyBackendBucketRequest()];

coerce 'RepeatedSetIamPolicyBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyBackendBucketRequest',
    as HashRef[SetIamPolicyBackendBucketRequest()];

declare 'SetIamPolicyBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyBackendServiceRequest'];

coerce 'SetIamPolicyBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyBackendServiceRequest'->new($_) };

declare 'RepeatedSetIamPolicyBackendServiceRequest',
    as ArrayRef[SetIamPolicyBackendServiceRequest()];

coerce 'RepeatedSetIamPolicyBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyBackendServiceRequest',
    as HashRef[SetIamPolicyBackendServiceRequest()];

declare 'SetIamPolicyDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyDiskRequest'];

coerce 'SetIamPolicyDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyDiskRequest'->new($_) };

declare 'RepeatedSetIamPolicyDiskRequest',
    as ArrayRef[SetIamPolicyDiskRequest()];

coerce 'RepeatedSetIamPolicyDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyDiskRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyDiskRequest',
    as HashRef[SetIamPolicyDiskRequest()];

declare 'SetIamPolicyFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyFirewallPolicyRequest'];

coerce 'SetIamPolicyFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyFirewallPolicyRequest'->new($_) };

declare 'RepeatedSetIamPolicyFirewallPolicyRequest',
    as ArrayRef[SetIamPolicyFirewallPolicyRequest()];

coerce 'RepeatedSetIamPolicyFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyFirewallPolicyRequest',
    as HashRef[SetIamPolicyFirewallPolicyRequest()];

declare 'SetIamPolicyImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyImageRequest'];

coerce 'SetIamPolicyImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyImageRequest'->new($_) };

declare 'RepeatedSetIamPolicyImageRequest',
    as ArrayRef[SetIamPolicyImageRequest()];

coerce 'RepeatedSetIamPolicyImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyImageRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyImageRequest',
    as HashRef[SetIamPolicyImageRequest()];

declare 'SetIamPolicyInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyInstanceRequest'];

coerce 'SetIamPolicyInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstanceRequest'->new($_) };

declare 'RepeatedSetIamPolicyInstanceRequest',
    as ArrayRef[SetIamPolicyInstanceRequest()];

coerce 'RepeatedSetIamPolicyInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyInstanceRequest',
    as HashRef[SetIamPolicyInstanceRequest()];

declare 'SetIamPolicyInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyInstanceTemplateRequest'];

coerce 'SetIamPolicyInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstanceTemplateRequest'->new($_) };

declare 'RepeatedSetIamPolicyInstanceTemplateRequest',
    as ArrayRef[SetIamPolicyInstanceTemplateRequest()];

coerce 'RepeatedSetIamPolicyInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyInstanceTemplateRequest',
    as HashRef[SetIamPolicyInstanceTemplateRequest()];

declare 'SetIamPolicyInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyInstantSnapshotGroupRequest'];

coerce 'SetIamPolicyInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedSetIamPolicyInstantSnapshotGroupRequest',
    as ArrayRef[SetIamPolicyInstantSnapshotGroupRequest()];

coerce 'RepeatedSetIamPolicyInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyInstantSnapshotGroupRequest',
    as HashRef[SetIamPolicyInstantSnapshotGroupRequest()];

declare 'SetIamPolicyInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyInstantSnapshotRequest'];

coerce 'SetIamPolicyInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstantSnapshotRequest'->new($_) };

declare 'RepeatedSetIamPolicyInstantSnapshotRequest',
    as ArrayRef[SetIamPolicyInstantSnapshotRequest()];

coerce 'RepeatedSetIamPolicyInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyInstantSnapshotRequest',
    as HashRef[SetIamPolicyInstantSnapshotRequest()];

declare 'SetIamPolicyInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyInterconnectAttachmentGroupRequest'];

coerce 'SetIamPolicyInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedSetIamPolicyInterconnectAttachmentGroupRequest',
    as ArrayRef[SetIamPolicyInterconnectAttachmentGroupRequest()];

coerce 'RepeatedSetIamPolicyInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyInterconnectAttachmentGroupRequest',
    as HashRef[SetIamPolicyInterconnectAttachmentGroupRequest()];

declare 'SetIamPolicyInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyInterconnectGroupRequest'];

coerce 'SetIamPolicyInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInterconnectGroupRequest'->new($_) };

declare 'RepeatedSetIamPolicyInterconnectGroupRequest',
    as ArrayRef[SetIamPolicyInterconnectGroupRequest()];

coerce 'RepeatedSetIamPolicyInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyInterconnectGroupRequest',
    as HashRef[SetIamPolicyInterconnectGroupRequest()];

declare 'SetIamPolicyLicenseCodeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyLicenseCodeRequest'];

coerce 'SetIamPolicyLicenseCodeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyLicenseCodeRequest'->new($_) };

declare 'RepeatedSetIamPolicyLicenseCodeRequest',
    as ArrayRef[SetIamPolicyLicenseCodeRequest()];

coerce 'RepeatedSetIamPolicyLicenseCodeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyLicenseCodeRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyLicenseCodeRequest',
    as HashRef[SetIamPolicyLicenseCodeRequest()];

declare 'SetIamPolicyLicenseRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyLicenseRequest'];

coerce 'SetIamPolicyLicenseRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyLicenseRequest'->new($_) };

declare 'RepeatedSetIamPolicyLicenseRequest',
    as ArrayRef[SetIamPolicyLicenseRequest()];

coerce 'RepeatedSetIamPolicyLicenseRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyLicenseRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyLicenseRequest',
    as HashRef[SetIamPolicyLicenseRequest()];

declare 'SetIamPolicyMachineImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyMachineImageRequest'];

coerce 'SetIamPolicyMachineImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyMachineImageRequest'->new($_) };

declare 'RepeatedSetIamPolicyMachineImageRequest',
    as ArrayRef[SetIamPolicyMachineImageRequest()];

coerce 'RepeatedSetIamPolicyMachineImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyMachineImageRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyMachineImageRequest',
    as HashRef[SetIamPolicyMachineImageRequest()];

declare 'SetIamPolicyNetworkAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyNetworkAttachmentRequest'];

coerce 'SetIamPolicyNetworkAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNetworkAttachmentRequest'->new($_) };

declare 'RepeatedSetIamPolicyNetworkAttachmentRequest',
    as ArrayRef[SetIamPolicyNetworkAttachmentRequest()];

coerce 'RepeatedSetIamPolicyNetworkAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNetworkAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyNetworkAttachmentRequest',
    as HashRef[SetIamPolicyNetworkAttachmentRequest()];

declare 'SetIamPolicyNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyNetworkFirewallPolicyRequest'];

coerce 'SetIamPolicyNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedSetIamPolicyNetworkFirewallPolicyRequest',
    as ArrayRef[SetIamPolicyNetworkFirewallPolicyRequest()];

coerce 'RepeatedSetIamPolicyNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyNetworkFirewallPolicyRequest',
    as HashRef[SetIamPolicyNetworkFirewallPolicyRequest()];

declare 'SetIamPolicyNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyNodeGroupRequest'];

coerce 'SetIamPolicyNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNodeGroupRequest'->new($_) };

declare 'RepeatedSetIamPolicyNodeGroupRequest',
    as ArrayRef[SetIamPolicyNodeGroupRequest()];

coerce 'RepeatedSetIamPolicyNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyNodeGroupRequest',
    as HashRef[SetIamPolicyNodeGroupRequest()];

declare 'SetIamPolicyNodeTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyNodeTemplateRequest'];

coerce 'SetIamPolicyNodeTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNodeTemplateRequest'->new($_) };

declare 'RepeatedSetIamPolicyNodeTemplateRequest',
    as ArrayRef[SetIamPolicyNodeTemplateRequest()];

coerce 'RepeatedSetIamPolicyNodeTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyNodeTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyNodeTemplateRequest',
    as HashRef[SetIamPolicyNodeTemplateRequest()];

declare 'SetIamPolicyRegionBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionBackendBucketRequest'];

coerce 'SetIamPolicyRegionBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionBackendBucketRequest'->new($_) };

declare 'RepeatedSetIamPolicyRegionBackendBucketRequest',
    as ArrayRef[SetIamPolicyRegionBackendBucketRequest()];

coerce 'RepeatedSetIamPolicyRegionBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyRegionBackendBucketRequest',
    as HashRef[SetIamPolicyRegionBackendBucketRequest()];

declare 'SetIamPolicyRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionBackendServiceRequest'];

coerce 'SetIamPolicyRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionBackendServiceRequest'->new($_) };

declare 'RepeatedSetIamPolicyRegionBackendServiceRequest',
    as ArrayRef[SetIamPolicyRegionBackendServiceRequest()];

coerce 'RepeatedSetIamPolicyRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyRegionBackendServiceRequest',
    as HashRef[SetIamPolicyRegionBackendServiceRequest()];

declare 'SetIamPolicyRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionDiskRequest'];

coerce 'SetIamPolicyRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionDiskRequest'->new($_) };

declare 'RepeatedSetIamPolicyRegionDiskRequest',
    as ArrayRef[SetIamPolicyRegionDiskRequest()];

coerce 'RepeatedSetIamPolicyRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyRegionDiskRequest',
    as HashRef[SetIamPolicyRegionDiskRequest()];

declare 'SetIamPolicyRegionInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionInstantSnapshotGroupRequest'];

coerce 'SetIamPolicyRegionInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedSetIamPolicyRegionInstantSnapshotGroupRequest',
    as ArrayRef[SetIamPolicyRegionInstantSnapshotGroupRequest()];

coerce 'RepeatedSetIamPolicyRegionInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyRegionInstantSnapshotGroupRequest',
    as HashRef[SetIamPolicyRegionInstantSnapshotGroupRequest()];

declare 'SetIamPolicyRegionInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionInstantSnapshotRequest'];

coerce 'SetIamPolicyRegionInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionInstantSnapshotRequest'->new($_) };

declare 'RepeatedSetIamPolicyRegionInstantSnapshotRequest',
    as ArrayRef[SetIamPolicyRegionInstantSnapshotRequest()];

coerce 'RepeatedSetIamPolicyRegionInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyRegionInstantSnapshotRequest',
    as HashRef[SetIamPolicyRegionInstantSnapshotRequest()];

declare 'SetIamPolicyRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionNetworkFirewallPolicyRequest'];

coerce 'SetIamPolicyRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedSetIamPolicyRegionNetworkFirewallPolicyRequest',
    as ArrayRef[SetIamPolicyRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedSetIamPolicyRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyRegionNetworkFirewallPolicyRequest',
    as HashRef[SetIamPolicyRegionNetworkFirewallPolicyRequest()];

declare 'SetIamPolicyRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionSnapshotRequest'];

coerce 'SetIamPolicyRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionSnapshotRequest'->new($_) };

declare 'RepeatedSetIamPolicyRegionSnapshotRequest',
    as ArrayRef[SetIamPolicyRegionSnapshotRequest()];

coerce 'RepeatedSetIamPolicyRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyRegionSnapshotRequest',
    as HashRef[SetIamPolicyRegionSnapshotRequest()];

declare 'SetIamPolicyReservationBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationBlockRequest'];

coerce 'SetIamPolicyReservationBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationBlockRequest'->new($_) };

declare 'RepeatedSetIamPolicyReservationBlockRequest',
    as ArrayRef[SetIamPolicyReservationBlockRequest()];

coerce 'RepeatedSetIamPolicyReservationBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationBlockRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyReservationBlockRequest',
    as HashRef[SetIamPolicyReservationBlockRequest()];

declare 'SetIamPolicyReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationRequest'];

coerce 'SetIamPolicyReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationRequest'->new($_) };

declare 'RepeatedSetIamPolicyReservationRequest',
    as ArrayRef[SetIamPolicyReservationRequest()];

coerce 'RepeatedSetIamPolicyReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyReservationRequest',
    as HashRef[SetIamPolicyReservationRequest()];

declare 'SetIamPolicyReservationSubBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationSubBlockRequest'];

coerce 'SetIamPolicyReservationSubBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationSubBlockRequest'->new($_) };

declare 'RepeatedSetIamPolicyReservationSubBlockRequest',
    as ArrayRef[SetIamPolicyReservationSubBlockRequest()];

coerce 'RepeatedSetIamPolicyReservationSubBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyReservationSubBlockRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyReservationSubBlockRequest',
    as HashRef[SetIamPolicyReservationSubBlockRequest()];

declare 'SetIamPolicyResourcePolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyResourcePolicyRequest'];

coerce 'SetIamPolicyResourcePolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyResourcePolicyRequest'->new($_) };

declare 'RepeatedSetIamPolicyResourcePolicyRequest',
    as ArrayRef[SetIamPolicyResourcePolicyRequest()];

coerce 'RepeatedSetIamPolicyResourcePolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyResourcePolicyRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyResourcePolicyRequest',
    as HashRef[SetIamPolicyResourcePolicyRequest()];

declare 'SetIamPolicyServiceAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyServiceAttachmentRequest'];

coerce 'SetIamPolicyServiceAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyServiceAttachmentRequest'->new($_) };

declare 'RepeatedSetIamPolicyServiceAttachmentRequest',
    as ArrayRef[SetIamPolicyServiceAttachmentRequest()];

coerce 'RepeatedSetIamPolicyServiceAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyServiceAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyServiceAttachmentRequest',
    as HashRef[SetIamPolicyServiceAttachmentRequest()];

declare 'SetIamPolicySnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicySnapshotRequest'];

coerce 'SetIamPolicySnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicySnapshotRequest'->new($_) };

declare 'RepeatedSetIamPolicySnapshotRequest',
    as ArrayRef[SetIamPolicySnapshotRequest()];

coerce 'RepeatedSetIamPolicySnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicySnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicySnapshotRequest',
    as HashRef[SetIamPolicySnapshotRequest()];

declare 'SetIamPolicyStoragePoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicyStoragePoolRequest'];

coerce 'SetIamPolicyStoragePoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyStoragePoolRequest'->new($_) };

declare 'RepeatedSetIamPolicyStoragePoolRequest',
    as ArrayRef[SetIamPolicyStoragePoolRequest()];

coerce 'RepeatedSetIamPolicyStoragePoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicyStoragePoolRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicyStoragePoolRequest',
    as HashRef[SetIamPolicyStoragePoolRequest()];

declare 'SetIamPolicySubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetIamPolicySubnetworkRequest'];

coerce 'SetIamPolicySubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetIamPolicySubnetworkRequest'->new($_) };

declare 'RepeatedSetIamPolicySubnetworkRequest',
    as ArrayRef[SetIamPolicySubnetworkRequest()];

coerce 'RepeatedSetIamPolicySubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetIamPolicySubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringSetIamPolicySubnetworkRequest',
    as HashRef[SetIamPolicySubnetworkRequest()];

declare 'SetInstanceTemplateInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetInstanceTemplateInstanceGroupManagerRequest'];

coerce 'SetInstanceTemplateInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetInstanceTemplateInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedSetInstanceTemplateInstanceGroupManagerRequest',
    as ArrayRef[SetInstanceTemplateInstanceGroupManagerRequest()];

coerce 'RepeatedSetInstanceTemplateInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetInstanceTemplateInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringSetInstanceTemplateInstanceGroupManagerRequest',
    as HashRef[SetInstanceTemplateInstanceGroupManagerRequest()];

declare 'SetInstanceTemplateRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetInstanceTemplateRegionInstanceGroupManagerRequest'];

coerce 'SetInstanceTemplateRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetInstanceTemplateRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedSetInstanceTemplateRegionInstanceGroupManagerRequest',
    as ArrayRef[SetInstanceTemplateRegionInstanceGroupManagerRequest()];

coerce 'RepeatedSetInstanceTemplateRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetInstanceTemplateRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringSetInstanceTemplateRegionInstanceGroupManagerRequest',
    as HashRef[SetInstanceTemplateRegionInstanceGroupManagerRequest()];

declare 'SetLabelsAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsAddressRequest'];

coerce 'SetLabelsAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsAddressRequest'->new($_) };

declare 'RepeatedSetLabelsAddressRequest',
    as ArrayRef[SetLabelsAddressRequest()];

coerce 'RepeatedSetLabelsAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsAddressRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsAddressRequest',
    as HashRef[SetLabelsAddressRequest()];

declare 'SetLabelsDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsDiskRequest'];

coerce 'SetLabelsDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsDiskRequest'->new($_) };

declare 'RepeatedSetLabelsDiskRequest',
    as ArrayRef[SetLabelsDiskRequest()];

coerce 'RepeatedSetLabelsDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsDiskRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsDiskRequest',
    as HashRef[SetLabelsDiskRequest()];

declare 'SetLabelsExternalVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsExternalVpnGatewayRequest'];

coerce 'SetLabelsExternalVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsExternalVpnGatewayRequest'->new($_) };

declare 'RepeatedSetLabelsExternalVpnGatewayRequest',
    as ArrayRef[SetLabelsExternalVpnGatewayRequest()];

coerce 'RepeatedSetLabelsExternalVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsExternalVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsExternalVpnGatewayRequest',
    as HashRef[SetLabelsExternalVpnGatewayRequest()];

declare 'SetLabelsForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsForwardingRuleRequest'];

coerce 'SetLabelsForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsForwardingRuleRequest'->new($_) };

declare 'RepeatedSetLabelsForwardingRuleRequest',
    as ArrayRef[SetLabelsForwardingRuleRequest()];

coerce 'RepeatedSetLabelsForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsForwardingRuleRequest',
    as HashRef[SetLabelsForwardingRuleRequest()];

declare 'SetLabelsGlobalAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsGlobalAddressRequest'];

coerce 'SetLabelsGlobalAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsGlobalAddressRequest'->new($_) };

declare 'RepeatedSetLabelsGlobalAddressRequest',
    as ArrayRef[SetLabelsGlobalAddressRequest()];

coerce 'RepeatedSetLabelsGlobalAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsGlobalAddressRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsGlobalAddressRequest',
    as HashRef[SetLabelsGlobalAddressRequest()];

declare 'SetLabelsGlobalForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsGlobalForwardingRuleRequest'];

coerce 'SetLabelsGlobalForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsGlobalForwardingRuleRequest'->new($_) };

declare 'RepeatedSetLabelsGlobalForwardingRuleRequest',
    as ArrayRef[SetLabelsGlobalForwardingRuleRequest()];

coerce 'RepeatedSetLabelsGlobalForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsGlobalForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsGlobalForwardingRuleRequest',
    as HashRef[SetLabelsGlobalForwardingRuleRequest()];

declare 'SetLabelsImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsImageRequest'];

coerce 'SetLabelsImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsImageRequest'->new($_) };

declare 'RepeatedSetLabelsImageRequest',
    as ArrayRef[SetLabelsImageRequest()];

coerce 'RepeatedSetLabelsImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsImageRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsImageRequest',
    as HashRef[SetLabelsImageRequest()];

declare 'SetLabelsInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsInstanceRequest'];

coerce 'SetLabelsInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsInstanceRequest'->new($_) };

declare 'RepeatedSetLabelsInstanceRequest',
    as ArrayRef[SetLabelsInstanceRequest()];

coerce 'RepeatedSetLabelsInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsInstanceRequest',
    as HashRef[SetLabelsInstanceRequest()];

declare 'SetLabelsInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsInstantSnapshotRequest'];

coerce 'SetLabelsInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsInstantSnapshotRequest'->new($_) };

declare 'RepeatedSetLabelsInstantSnapshotRequest',
    as ArrayRef[SetLabelsInstantSnapshotRequest()];

coerce 'RepeatedSetLabelsInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsInstantSnapshotRequest',
    as HashRef[SetLabelsInstantSnapshotRequest()];

declare 'SetLabelsInterconnectAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsInterconnectAttachmentRequest'];

coerce 'SetLabelsInterconnectAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsInterconnectAttachmentRequest'->new($_) };

declare 'RepeatedSetLabelsInterconnectAttachmentRequest',
    as ArrayRef[SetLabelsInterconnectAttachmentRequest()];

coerce 'RepeatedSetLabelsInterconnectAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsInterconnectAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsInterconnectAttachmentRequest',
    as HashRef[SetLabelsInterconnectAttachmentRequest()];

declare 'SetLabelsInterconnectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsInterconnectRequest'];

coerce 'SetLabelsInterconnectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsInterconnectRequest'->new($_) };

declare 'RepeatedSetLabelsInterconnectRequest',
    as ArrayRef[SetLabelsInterconnectRequest()];

coerce 'RepeatedSetLabelsInterconnectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsInterconnectRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsInterconnectRequest',
    as HashRef[SetLabelsInterconnectRequest()];

declare 'SetLabelsMachineImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsMachineImageRequest'];

coerce 'SetLabelsMachineImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsMachineImageRequest'->new($_) };

declare 'RepeatedSetLabelsMachineImageRequest',
    as ArrayRef[SetLabelsMachineImageRequest()];

coerce 'RepeatedSetLabelsMachineImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsMachineImageRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsMachineImageRequest',
    as HashRef[SetLabelsMachineImageRequest()];

declare 'SetLabelsRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsRegionDiskRequest'];

coerce 'SetLabelsRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionDiskRequest'->new($_) };

declare 'RepeatedSetLabelsRegionDiskRequest',
    as ArrayRef[SetLabelsRegionDiskRequest()];

coerce 'RepeatedSetLabelsRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsRegionDiskRequest',
    as HashRef[SetLabelsRegionDiskRequest()];

declare 'SetLabelsRegionInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsRegionInstantSnapshotRequest'];

coerce 'SetLabelsRegionInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionInstantSnapshotRequest'->new($_) };

declare 'RepeatedSetLabelsRegionInstantSnapshotRequest',
    as ArrayRef[SetLabelsRegionInstantSnapshotRequest()];

coerce 'RepeatedSetLabelsRegionInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsRegionInstantSnapshotRequest',
    as HashRef[SetLabelsRegionInstantSnapshotRequest()];

declare 'SetLabelsRegionSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsRegionSecurityPolicyRequest'];

coerce 'SetLabelsRegionSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionSecurityPolicyRequest'->new($_) };

declare 'RepeatedSetLabelsRegionSecurityPolicyRequest',
    as ArrayRef[SetLabelsRegionSecurityPolicyRequest()];

coerce 'RepeatedSetLabelsRegionSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsRegionSecurityPolicyRequest',
    as HashRef[SetLabelsRegionSecurityPolicyRequest()];

declare 'SetLabelsRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsRegionSnapshotRequest'];

coerce 'SetLabelsRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionSnapshotRequest'->new($_) };

declare 'RepeatedSetLabelsRegionSnapshotRequest',
    as ArrayRef[SetLabelsRegionSnapshotRequest()];

coerce 'RepeatedSetLabelsRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsRegionSnapshotRequest',
    as HashRef[SetLabelsRegionSnapshotRequest()];

declare 'SetLabelsSecurityPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsSecurityPolicyRequest'];

coerce 'SetLabelsSecurityPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsSecurityPolicyRequest'->new($_) };

declare 'RepeatedSetLabelsSecurityPolicyRequest',
    as ArrayRef[SetLabelsSecurityPolicyRequest()];

coerce 'RepeatedSetLabelsSecurityPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsSecurityPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsSecurityPolicyRequest',
    as HashRef[SetLabelsSecurityPolicyRequest()];

declare 'SetLabelsSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsSnapshotRequest'];

coerce 'SetLabelsSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsSnapshotRequest'->new($_) };

declare 'RepeatedSetLabelsSnapshotRequest',
    as ArrayRef[SetLabelsSnapshotRequest()];

coerce 'RepeatedSetLabelsSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsSnapshotRequest',
    as HashRef[SetLabelsSnapshotRequest()];

declare 'SetLabelsTargetVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsTargetVpnGatewayRequest'];

coerce 'SetLabelsTargetVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsTargetVpnGatewayRequest'->new($_) };

declare 'RepeatedSetLabelsTargetVpnGatewayRequest',
    as ArrayRef[SetLabelsTargetVpnGatewayRequest()];

coerce 'RepeatedSetLabelsTargetVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsTargetVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsTargetVpnGatewayRequest',
    as HashRef[SetLabelsTargetVpnGatewayRequest()];

declare 'SetLabelsVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsVpnGatewayRequest'];

coerce 'SetLabelsVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsVpnGatewayRequest'->new($_) };

declare 'RepeatedSetLabelsVpnGatewayRequest',
    as ArrayRef[SetLabelsVpnGatewayRequest()];

coerce 'RepeatedSetLabelsVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsVpnGatewayRequest',
    as HashRef[SetLabelsVpnGatewayRequest()];

declare 'SetLabelsVpnTunnelRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetLabelsVpnTunnelRequest'];

coerce 'SetLabelsVpnTunnelRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetLabelsVpnTunnelRequest'->new($_) };

declare 'RepeatedSetLabelsVpnTunnelRequest',
    as ArrayRef[SetLabelsVpnTunnelRequest()];

coerce 'RepeatedSetLabelsVpnTunnelRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetLabelsVpnTunnelRequest'->new($_) } @$_ ] };

declare 'MapStringSetLabelsVpnTunnelRequest',
    as HashRef[SetLabelsVpnTunnelRequest()];

declare 'SetMachineResourcesInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetMachineResourcesInstanceRequest'];

coerce 'SetMachineResourcesInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetMachineResourcesInstanceRequest'->new($_) };

declare 'RepeatedSetMachineResourcesInstanceRequest',
    as ArrayRef[SetMachineResourcesInstanceRequest()];

coerce 'RepeatedSetMachineResourcesInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetMachineResourcesInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetMachineResourcesInstanceRequest',
    as HashRef[SetMachineResourcesInstanceRequest()];

declare 'SetMachineTypeInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetMachineTypeInstanceRequest'];

coerce 'SetMachineTypeInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetMachineTypeInstanceRequest'->new($_) };

declare 'RepeatedSetMachineTypeInstanceRequest',
    as ArrayRef[SetMachineTypeInstanceRequest()];

coerce 'RepeatedSetMachineTypeInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetMachineTypeInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetMachineTypeInstanceRequest',
    as HashRef[SetMachineTypeInstanceRequest()];

declare 'SetMetadataInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetMetadataInstanceRequest'];

coerce 'SetMetadataInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetMetadataInstanceRequest'->new($_) };

declare 'RepeatedSetMetadataInstanceRequest',
    as ArrayRef[SetMetadataInstanceRequest()];

coerce 'RepeatedSetMetadataInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetMetadataInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetMetadataInstanceRequest',
    as HashRef[SetMetadataInstanceRequest()];

declare 'SetMinCpuPlatformInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetMinCpuPlatformInstanceRequest'];

coerce 'SetMinCpuPlatformInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetMinCpuPlatformInstanceRequest'->new($_) };

declare 'RepeatedSetMinCpuPlatformInstanceRequest',
    as ArrayRef[SetMinCpuPlatformInstanceRequest()];

coerce 'RepeatedSetMinCpuPlatformInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetMinCpuPlatformInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetMinCpuPlatformInstanceRequest',
    as HashRef[SetMinCpuPlatformInstanceRequest()];

declare 'SetNameInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetNameInstanceRequest'];

coerce 'SetNameInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetNameInstanceRequest'->new($_) };

declare 'RepeatedSetNameInstanceRequest',
    as ArrayRef[SetNameInstanceRequest()];

coerce 'RepeatedSetNameInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetNameInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetNameInstanceRequest',
    as HashRef[SetNameInstanceRequest()];

declare 'SetNamedPortsInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetNamedPortsInstanceGroupRequest'];

coerce 'SetNamedPortsInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetNamedPortsInstanceGroupRequest'->new($_) };

declare 'RepeatedSetNamedPortsInstanceGroupRequest',
    as ArrayRef[SetNamedPortsInstanceGroupRequest()];

coerce 'RepeatedSetNamedPortsInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetNamedPortsInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetNamedPortsInstanceGroupRequest',
    as HashRef[SetNamedPortsInstanceGroupRequest()];

declare 'SetNamedPortsRegionInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetNamedPortsRegionInstanceGroupRequest'];

coerce 'SetNamedPortsRegionInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetNamedPortsRegionInstanceGroupRequest'->new($_) };

declare 'RepeatedSetNamedPortsRegionInstanceGroupRequest',
    as ArrayRef[SetNamedPortsRegionInstanceGroupRequest()];

coerce 'RepeatedSetNamedPortsRegionInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetNamedPortsRegionInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetNamedPortsRegionInstanceGroupRequest',
    as HashRef[SetNamedPortsRegionInstanceGroupRequest()];

declare 'SetNodeTemplateNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetNodeTemplateNodeGroupRequest'];

coerce 'SetNodeTemplateNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetNodeTemplateNodeGroupRequest'->new($_) };

declare 'RepeatedSetNodeTemplateNodeGroupRequest',
    as ArrayRef[SetNodeTemplateNodeGroupRequest()];

coerce 'RepeatedSetNodeTemplateNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetNodeTemplateNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSetNodeTemplateNodeGroupRequest',
    as HashRef[SetNodeTemplateNodeGroupRequest()];

declare 'SetPrivateIpGoogleAccessSubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetPrivateIpGoogleAccessSubnetworkRequest'];

coerce 'SetPrivateIpGoogleAccessSubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetPrivateIpGoogleAccessSubnetworkRequest'->new($_) };

declare 'RepeatedSetPrivateIpGoogleAccessSubnetworkRequest',
    as ArrayRef[SetPrivateIpGoogleAccessSubnetworkRequest()];

coerce 'RepeatedSetPrivateIpGoogleAccessSubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetPrivateIpGoogleAccessSubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringSetPrivateIpGoogleAccessSubnetworkRequest',
    as HashRef[SetPrivateIpGoogleAccessSubnetworkRequest()];

declare 'SetProxyHeaderTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetProxyHeaderTargetSslProxyRequest'];

coerce 'SetProxyHeaderTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetProxyHeaderTargetSslProxyRequest'->new($_) };

declare 'RepeatedSetProxyHeaderTargetSslProxyRequest',
    as ArrayRef[SetProxyHeaderTargetSslProxyRequest()];

coerce 'RepeatedSetProxyHeaderTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetProxyHeaderTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetProxyHeaderTargetSslProxyRequest',
    as HashRef[SetProxyHeaderTargetSslProxyRequest()];

declare 'SetProxyHeaderTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetProxyHeaderTargetTcpProxyRequest'];

coerce 'SetProxyHeaderTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetProxyHeaderTargetTcpProxyRequest'->new($_) };

declare 'RepeatedSetProxyHeaderTargetTcpProxyRequest',
    as ArrayRef[SetProxyHeaderTargetTcpProxyRequest()];

coerce 'RepeatedSetProxyHeaderTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetProxyHeaderTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetProxyHeaderTargetTcpProxyRequest',
    as HashRef[SetProxyHeaderTargetTcpProxyRequest()];

declare 'SetQuicOverrideTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetQuicOverrideTargetHttpsProxyRequest'];

coerce 'SetQuicOverrideTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetQuicOverrideTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedSetQuicOverrideTargetHttpsProxyRequest',
    as ArrayRef[SetQuicOverrideTargetHttpsProxyRequest()];

coerce 'RepeatedSetQuicOverrideTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetQuicOverrideTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetQuicOverrideTargetHttpsProxyRequest',
    as HashRef[SetQuicOverrideTargetHttpsProxyRequest()];

declare 'SetSchedulingInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSchedulingInstanceRequest'];

coerce 'SetSchedulingInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSchedulingInstanceRequest'->new($_) };

declare 'RepeatedSetSchedulingInstanceRequest',
    as ArrayRef[SetSchedulingInstanceRequest()];

coerce 'RepeatedSetSchedulingInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSchedulingInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetSchedulingInstanceRequest',
    as HashRef[SetSchedulingInstanceRequest()];

declare 'SetSecurityPolicyBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSecurityPolicyBackendServiceRequest'];

coerce 'SetSecurityPolicyBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyBackendServiceRequest'->new($_) };

declare 'RepeatedSetSecurityPolicyBackendServiceRequest',
    as ArrayRef[SetSecurityPolicyBackendServiceRequest()];

coerce 'RepeatedSetSecurityPolicyBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringSetSecurityPolicyBackendServiceRequest',
    as HashRef[SetSecurityPolicyBackendServiceRequest()];

declare 'SetSecurityPolicyInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSecurityPolicyInstanceRequest'];

coerce 'SetSecurityPolicyInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyInstanceRequest'->new($_) };

declare 'RepeatedSetSecurityPolicyInstanceRequest',
    as ArrayRef[SetSecurityPolicyInstanceRequest()];

coerce 'RepeatedSetSecurityPolicyInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetSecurityPolicyInstanceRequest',
    as HashRef[SetSecurityPolicyInstanceRequest()];

declare 'SetSecurityPolicyRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSecurityPolicyRegionBackendServiceRequest'];

coerce 'SetSecurityPolicyRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyRegionBackendServiceRequest'->new($_) };

declare 'RepeatedSetSecurityPolicyRegionBackendServiceRequest',
    as ArrayRef[SetSecurityPolicyRegionBackendServiceRequest()];

coerce 'RepeatedSetSecurityPolicyRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringSetSecurityPolicyRegionBackendServiceRequest',
    as HashRef[SetSecurityPolicyRegionBackendServiceRequest()];

declare 'SetSecurityPolicyTargetInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSecurityPolicyTargetInstanceRequest'];

coerce 'SetSecurityPolicyTargetInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyTargetInstanceRequest'->new($_) };

declare 'RepeatedSetSecurityPolicyTargetInstanceRequest',
    as ArrayRef[SetSecurityPolicyTargetInstanceRequest()];

coerce 'RepeatedSetSecurityPolicyTargetInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyTargetInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetSecurityPolicyTargetInstanceRequest',
    as HashRef[SetSecurityPolicyTargetInstanceRequest()];

declare 'SetSecurityPolicyTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSecurityPolicyTargetPoolRequest'];

coerce 'SetSecurityPolicyTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyTargetPoolRequest'->new($_) };

declare 'RepeatedSetSecurityPolicyTargetPoolRequest',
    as ArrayRef[SetSecurityPolicyTargetPoolRequest()];

coerce 'RepeatedSetSecurityPolicyTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSecurityPolicyTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringSetSecurityPolicyTargetPoolRequest',
    as HashRef[SetSecurityPolicyTargetPoolRequest()];

declare 'SetServiceAccountInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetServiceAccountInstanceRequest'];

coerce 'SetServiceAccountInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetServiceAccountInstanceRequest'->new($_) };

declare 'RepeatedSetServiceAccountInstanceRequest',
    as ArrayRef[SetServiceAccountInstanceRequest()];

coerce 'RepeatedSetServiceAccountInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetServiceAccountInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetServiceAccountInstanceRequest',
    as HashRef[SetServiceAccountInstanceRequest()];

declare 'SetShieldedInstanceIntegrityPolicyInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetShieldedInstanceIntegrityPolicyInstanceRequest'];

coerce 'SetShieldedInstanceIntegrityPolicyInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetShieldedInstanceIntegrityPolicyInstanceRequest'->new($_) };

declare 'RepeatedSetShieldedInstanceIntegrityPolicyInstanceRequest',
    as ArrayRef[SetShieldedInstanceIntegrityPolicyInstanceRequest()];

coerce 'RepeatedSetShieldedInstanceIntegrityPolicyInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetShieldedInstanceIntegrityPolicyInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetShieldedInstanceIntegrityPolicyInstanceRequest',
    as HashRef[SetShieldedInstanceIntegrityPolicyInstanceRequest()];

declare 'SetSslCertificatesRegionTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSslCertificatesRegionTargetHttpsProxyRequest'];

coerce 'SetSslCertificatesRegionTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSslCertificatesRegionTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedSetSslCertificatesRegionTargetHttpsProxyRequest',
    as ArrayRef[SetSslCertificatesRegionTargetHttpsProxyRequest()];

coerce 'RepeatedSetSslCertificatesRegionTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSslCertificatesRegionTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetSslCertificatesRegionTargetHttpsProxyRequest',
    as HashRef[SetSslCertificatesRegionTargetHttpsProxyRequest()];

declare 'SetSslCertificatesTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSslCertificatesTargetHttpsProxyRequest'];

coerce 'SetSslCertificatesTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSslCertificatesTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedSetSslCertificatesTargetHttpsProxyRequest',
    as ArrayRef[SetSslCertificatesTargetHttpsProxyRequest()];

coerce 'RepeatedSetSslCertificatesTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSslCertificatesTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetSslCertificatesTargetHttpsProxyRequest',
    as HashRef[SetSslCertificatesTargetHttpsProxyRequest()];

declare 'SetSslCertificatesTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSslCertificatesTargetSslProxyRequest'];

coerce 'SetSslCertificatesTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSslCertificatesTargetSslProxyRequest'->new($_) };

declare 'RepeatedSetSslCertificatesTargetSslProxyRequest',
    as ArrayRef[SetSslCertificatesTargetSslProxyRequest()];

coerce 'RepeatedSetSslCertificatesTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSslCertificatesTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetSslCertificatesTargetSslProxyRequest',
    as HashRef[SetSslCertificatesTargetSslProxyRequest()];

declare 'SetSslPolicyTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSslPolicyTargetHttpsProxyRequest'];

coerce 'SetSslPolicyTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSslPolicyTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedSetSslPolicyTargetHttpsProxyRequest',
    as ArrayRef[SetSslPolicyTargetHttpsProxyRequest()];

coerce 'RepeatedSetSslPolicyTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSslPolicyTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetSslPolicyTargetHttpsProxyRequest',
    as HashRef[SetSslPolicyTargetHttpsProxyRequest()];

declare 'SetSslPolicyTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetSslPolicyTargetSslProxyRequest'];

coerce 'SetSslPolicyTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetSslPolicyTargetSslProxyRequest'->new($_) };

declare 'RepeatedSetSslPolicyTargetSslProxyRequest',
    as ArrayRef[SetSslPolicyTargetSslProxyRequest()];

coerce 'RepeatedSetSslPolicyTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetSslPolicyTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetSslPolicyTargetSslProxyRequest',
    as HashRef[SetSslPolicyTargetSslProxyRequest()];

declare 'SetTagsInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetTagsInstanceRequest'];

coerce 'SetTagsInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetTagsInstanceRequest'->new($_) };

declare 'RepeatedSetTagsInstanceRequest',
    as ArrayRef[SetTagsInstanceRequest()];

coerce 'RepeatedSetTagsInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetTagsInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSetTagsInstanceRequest',
    as HashRef[SetTagsInstanceRequest()];

declare 'SetTargetForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetTargetForwardingRuleRequest'];

coerce 'SetTargetForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetTargetForwardingRuleRequest'->new($_) };

declare 'RepeatedSetTargetForwardingRuleRequest',
    as ArrayRef[SetTargetForwardingRuleRequest()];

coerce 'RepeatedSetTargetForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetTargetForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringSetTargetForwardingRuleRequest',
    as HashRef[SetTargetForwardingRuleRequest()];

declare 'SetTargetGlobalForwardingRuleRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetTargetGlobalForwardingRuleRequest'];

coerce 'SetTargetGlobalForwardingRuleRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetTargetGlobalForwardingRuleRequest'->new($_) };

declare 'RepeatedSetTargetGlobalForwardingRuleRequest',
    as ArrayRef[SetTargetGlobalForwardingRuleRequest()];

coerce 'RepeatedSetTargetGlobalForwardingRuleRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetTargetGlobalForwardingRuleRequest'->new($_) } @$_ ] };

declare 'MapStringSetTargetGlobalForwardingRuleRequest',
    as HashRef[SetTargetGlobalForwardingRuleRequest()];

declare 'SetTargetPoolsInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetTargetPoolsInstanceGroupManagerRequest'];

coerce 'SetTargetPoolsInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetTargetPoolsInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedSetTargetPoolsInstanceGroupManagerRequest',
    as ArrayRef[SetTargetPoolsInstanceGroupManagerRequest()];

coerce 'RepeatedSetTargetPoolsInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetTargetPoolsInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringSetTargetPoolsInstanceGroupManagerRequest',
    as HashRef[SetTargetPoolsInstanceGroupManagerRequest()];

declare 'SetTargetPoolsRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetTargetPoolsRegionInstanceGroupManagerRequest'];

coerce 'SetTargetPoolsRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetTargetPoolsRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedSetTargetPoolsRegionInstanceGroupManagerRequest',
    as ArrayRef[SetTargetPoolsRegionInstanceGroupManagerRequest()];

coerce 'RepeatedSetTargetPoolsRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetTargetPoolsRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringSetTargetPoolsRegionInstanceGroupManagerRequest',
    as HashRef[SetTargetPoolsRegionInstanceGroupManagerRequest()];

declare 'SetUrlMapRegionTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetUrlMapRegionTargetHttpProxyRequest'];

coerce 'SetUrlMapRegionTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetUrlMapRegionTargetHttpProxyRequest'->new($_) };

declare 'RepeatedSetUrlMapRegionTargetHttpProxyRequest',
    as ArrayRef[SetUrlMapRegionTargetHttpProxyRequest()];

coerce 'RepeatedSetUrlMapRegionTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetUrlMapRegionTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetUrlMapRegionTargetHttpProxyRequest',
    as HashRef[SetUrlMapRegionTargetHttpProxyRequest()];

declare 'SetUrlMapRegionTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetUrlMapRegionTargetHttpsProxyRequest'];

coerce 'SetUrlMapRegionTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetUrlMapRegionTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedSetUrlMapRegionTargetHttpsProxyRequest',
    as ArrayRef[SetUrlMapRegionTargetHttpsProxyRequest()];

coerce 'RepeatedSetUrlMapRegionTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetUrlMapRegionTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetUrlMapRegionTargetHttpsProxyRequest',
    as HashRef[SetUrlMapRegionTargetHttpsProxyRequest()];

declare 'SetUrlMapTargetHttpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetUrlMapTargetHttpProxyRequest'];

coerce 'SetUrlMapTargetHttpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetUrlMapTargetHttpProxyRequest'->new($_) };

declare 'RepeatedSetUrlMapTargetHttpProxyRequest',
    as ArrayRef[SetUrlMapTargetHttpProxyRequest()];

coerce 'RepeatedSetUrlMapTargetHttpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetUrlMapTargetHttpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetUrlMapTargetHttpProxyRequest',
    as HashRef[SetUrlMapTargetHttpProxyRequest()];

declare 'SetUrlMapTargetHttpsProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetUrlMapTargetHttpsProxyRequest'];

coerce 'SetUrlMapTargetHttpsProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetUrlMapTargetHttpsProxyRequest'->new($_) };

declare 'RepeatedSetUrlMapTargetHttpsProxyRequest',
    as ArrayRef[SetUrlMapTargetHttpsProxyRequest()];

coerce 'RepeatedSetUrlMapTargetHttpsProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetUrlMapTargetHttpsProxyRequest'->new($_) } @$_ ] };

declare 'MapStringSetUrlMapTargetHttpsProxyRequest',
    as HashRef[SetUrlMapTargetHttpsProxyRequest()];

declare 'SetUsageExportBucketProjectRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SetUsageExportBucketProjectRequest'];

coerce 'SetUsageExportBucketProjectRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SetUsageExportBucketProjectRequest'->new($_) };

declare 'RepeatedSetUsageExportBucketProjectRequest',
    as ArrayRef[SetUsageExportBucketProjectRequest()];

coerce 'RepeatedSetUsageExportBucketProjectRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SetUsageExportBucketProjectRequest'->new($_) } @$_ ] };

declare 'MapStringSetUsageExportBucketProjectRequest',
    as HashRef[SetUsageExportBucketProjectRequest()];

declare 'ShareSettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ShareSettings'];

coerce 'ShareSettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ShareSettings'->new($_) };

declare 'RepeatedShareSettings',
    as ArrayRef[ShareSettings()];

coerce 'RepeatedShareSettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ShareSettings'->new($_) } @$_ ] };

declare 'MapStringShareSettings',
    as HashRef[ShareSettings()];

declare 'ShareType',
    as (Int | Str);

declare 'ProjectMapEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ShareSettings::ProjectMapEntry'];

coerce 'ProjectMapEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ShareSettings::ProjectMapEntry'->new($_) };

declare 'RepeatedProjectMapEntry',
    as ArrayRef[ProjectMapEntry()];

coerce 'RepeatedProjectMapEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ShareSettings::ProjectMapEntry'->new($_) } @$_ ] };

declare 'MapStringProjectMapEntry',
    as HashRef[ProjectMapEntry()];

declare 'ShareSettingsProjectConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ShareSettingsProjectConfig'];

coerce 'ShareSettingsProjectConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ShareSettingsProjectConfig'->new($_) };

declare 'RepeatedShareSettingsProjectConfig',
    as ArrayRef[ShareSettingsProjectConfig()];

coerce 'RepeatedShareSettingsProjectConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ShareSettingsProjectConfig'->new($_) } @$_ ] };

declare 'MapStringShareSettingsProjectConfig',
    as HashRef[ShareSettingsProjectConfig()];

declare 'ShieldedInstanceConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ShieldedInstanceConfig'];

coerce 'ShieldedInstanceConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceConfig'->new($_) };

declare 'RepeatedShieldedInstanceConfig',
    as ArrayRef[ShieldedInstanceConfig()];

coerce 'RepeatedShieldedInstanceConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceConfig'->new($_) } @$_ ] };

declare 'MapStringShieldedInstanceConfig',
    as HashRef[ShieldedInstanceConfig()];

declare 'ShieldedInstanceIdentity',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ShieldedInstanceIdentity'];

coerce 'ShieldedInstanceIdentity',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceIdentity'->new($_) };

declare 'RepeatedShieldedInstanceIdentity',
    as ArrayRef[ShieldedInstanceIdentity()];

coerce 'RepeatedShieldedInstanceIdentity',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceIdentity'->new($_) } @$_ ] };

declare 'MapStringShieldedInstanceIdentity',
    as HashRef[ShieldedInstanceIdentity()];

declare 'ShieldedInstanceIdentityEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ShieldedInstanceIdentityEntry'];

coerce 'ShieldedInstanceIdentityEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceIdentityEntry'->new($_) };

declare 'RepeatedShieldedInstanceIdentityEntry',
    as ArrayRef[ShieldedInstanceIdentityEntry()];

coerce 'RepeatedShieldedInstanceIdentityEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceIdentityEntry'->new($_) } @$_ ] };

declare 'MapStringShieldedInstanceIdentityEntry',
    as HashRef[ShieldedInstanceIdentityEntry()];

declare 'ShieldedInstanceIntegrityPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ShieldedInstanceIntegrityPolicy'];

coerce 'ShieldedInstanceIntegrityPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceIntegrityPolicy'->new($_) };

declare 'RepeatedShieldedInstanceIntegrityPolicy',
    as ArrayRef[ShieldedInstanceIntegrityPolicy()];

coerce 'RepeatedShieldedInstanceIntegrityPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ShieldedInstanceIntegrityPolicy'->new($_) } @$_ ] };

declare 'MapStringShieldedInstanceIntegrityPolicy',
    as HashRef[ShieldedInstanceIntegrityPolicy()];

declare 'SignedUrlKey',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SignedUrlKey'];

coerce 'SignedUrlKey',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SignedUrlKey'->new($_) };

declare 'RepeatedSignedUrlKey',
    as ArrayRef[SignedUrlKey()];

coerce 'RepeatedSignedUrlKey',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SignedUrlKey'->new($_) } @$_ ] };

declare 'MapStringSignedUrlKey',
    as HashRef[SignedUrlKey()];

declare 'SimulateMaintenanceEventInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SimulateMaintenanceEventInstanceRequest'];

coerce 'SimulateMaintenanceEventInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SimulateMaintenanceEventInstanceRequest'->new($_) };

declare 'RepeatedSimulateMaintenanceEventInstanceRequest',
    as ArrayRef[SimulateMaintenanceEventInstanceRequest()];

coerce 'RepeatedSimulateMaintenanceEventInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SimulateMaintenanceEventInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSimulateMaintenanceEventInstanceRequest',
    as HashRef[SimulateMaintenanceEventInstanceRequest()];

declare 'SimulateMaintenanceEventNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SimulateMaintenanceEventNodeGroupRequest'];

coerce 'SimulateMaintenanceEventNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SimulateMaintenanceEventNodeGroupRequest'->new($_) };

declare 'RepeatedSimulateMaintenanceEventNodeGroupRequest',
    as ArrayRef[SimulateMaintenanceEventNodeGroupRequest()];

coerce 'RepeatedSimulateMaintenanceEventNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SimulateMaintenanceEventNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringSimulateMaintenanceEventNodeGroupRequest',
    as HashRef[SimulateMaintenanceEventNodeGroupRequest()];

declare 'Snapshot',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Snapshot'];

coerce 'Snapshot',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Snapshot'->new($_) };

declare 'RepeatedSnapshot',
    as ArrayRef[Snapshot()];

coerce 'RepeatedSnapshot',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Snapshot'->new($_) } @$_ ] };

declare 'MapStringSnapshot',
    as HashRef[Snapshot()];

declare 'Architecture',
    as (Int | Str);

declare 'SnapshotType',
    as (Int | Str);

declare 'Status',
    as (Int | Str);

declare 'StorageBytesStatus',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Snapshot::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Snapshot::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Snapshot::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'SnapshotGroupParameters',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotGroupParameters'];

coerce 'SnapshotGroupParameters',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotGroupParameters'->new($_) };

declare 'RepeatedSnapshotGroupParameters',
    as ArrayRef[SnapshotGroupParameters()];

coerce 'RepeatedSnapshotGroupParameters',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotGroupParameters'->new($_) } @$_ ] };

declare 'MapStringSnapshotGroupParameters',
    as HashRef[SnapshotGroupParameters()];

declare 'SnapshotList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotList'];

coerce 'SnapshotList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotList'->new($_) };

declare 'RepeatedSnapshotList',
    as ArrayRef[SnapshotList()];

coerce 'RepeatedSnapshotList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotList'->new($_) } @$_ ] };

declare 'MapStringSnapshotList',
    as HashRef[SnapshotList()];

declare 'SnapshotParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotParams'];

coerce 'SnapshotParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotParams'->new($_) };

declare 'RepeatedSnapshotParams',
    as ArrayRef[SnapshotParams()];

coerce 'RepeatedSnapshotParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotParams'->new($_) } @$_ ] };

declare 'MapStringSnapshotParams',
    as HashRef[SnapshotParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'SnapshotSettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotSettings'];

coerce 'SnapshotSettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotSettings'->new($_) };

declare 'RepeatedSnapshotSettings',
    as ArrayRef[SnapshotSettings()];

coerce 'RepeatedSnapshotSettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotSettings'->new($_) } @$_ ] };

declare 'MapStringSnapshotSettings',
    as HashRef[SnapshotSettings()];

declare 'SnapshotSettingsAccessLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocation'];

coerce 'SnapshotSettingsAccessLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocation'->new($_) };

declare 'RepeatedSnapshotSettingsAccessLocation',
    as ArrayRef[SnapshotSettingsAccessLocation()];

coerce 'RepeatedSnapshotSettingsAccessLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocation'->new($_) } @$_ ] };

declare 'MapStringSnapshotSettingsAccessLocation',
    as HashRef[SnapshotSettingsAccessLocation()];

declare 'Policy',
    as (Int | Str);

declare 'LocationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocation::LocationsEntry'];

coerce 'LocationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocation::LocationsEntry'->new($_) };

declare 'RepeatedLocationsEntry',
    as ArrayRef[LocationsEntry()];

coerce 'RepeatedLocationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocation::LocationsEntry'->new($_) } @$_ ] };

declare 'MapStringLocationsEntry',
    as HashRef[LocationsEntry()];

declare 'SnapshotSettingsAccessLocationAccessLocationPreference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocationAccessLocationPreference'];

coerce 'SnapshotSettingsAccessLocationAccessLocationPreference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocationAccessLocationPreference'->new($_) };

declare 'RepeatedSnapshotSettingsAccessLocationAccessLocationPreference',
    as ArrayRef[SnapshotSettingsAccessLocationAccessLocationPreference()];

coerce 'RepeatedSnapshotSettingsAccessLocationAccessLocationPreference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsAccessLocationAccessLocationPreference'->new($_) } @$_ ] };

declare 'MapStringSnapshotSettingsAccessLocationAccessLocationPreference',
    as HashRef[SnapshotSettingsAccessLocationAccessLocationPreference()];

declare 'SnapshotSettingsStorageLocationSettings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettings'];

coerce 'SnapshotSettingsStorageLocationSettings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettings'->new($_) };

declare 'RepeatedSnapshotSettingsStorageLocationSettings',
    as ArrayRef[SnapshotSettingsStorageLocationSettings()];

coerce 'RepeatedSnapshotSettingsStorageLocationSettings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettings'->new($_) } @$_ ] };

declare 'MapStringSnapshotSettingsStorageLocationSettings',
    as HashRef[SnapshotSettingsStorageLocationSettings()];

declare 'Policy',
    as (Int | Str);

declare 'LocationsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettings::LocationsEntry'];

coerce 'LocationsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettings::LocationsEntry'->new($_) };

declare 'RepeatedLocationsEntry',
    as ArrayRef[LocationsEntry()];

coerce 'RepeatedLocationsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettings::LocationsEntry'->new($_) } @$_ ] };

declare 'MapStringLocationsEntry',
    as HashRef[LocationsEntry()];

declare 'SnapshotSettingsStorageLocationSettingsStorageLocationPreference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettingsStorageLocationPreference'];

coerce 'SnapshotSettingsStorageLocationSettingsStorageLocationPreference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettingsStorageLocationPreference'->new($_) };

declare 'RepeatedSnapshotSettingsStorageLocationSettingsStorageLocationPreference',
    as ArrayRef[SnapshotSettingsStorageLocationSettingsStorageLocationPreference()];

coerce 'RepeatedSnapshotSettingsStorageLocationSettingsStorageLocationPreference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotSettingsStorageLocationSettingsStorageLocationPreference'->new($_) } @$_ ] };

declare 'MapStringSnapshotSettingsStorageLocationSettingsStorageLocationPreference',
    as HashRef[SnapshotSettingsStorageLocationSettingsStorageLocationPreference()];

declare 'SnapshotUpdateKmsKeyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SnapshotUpdateKmsKeyRequest'];

coerce 'SnapshotUpdateKmsKeyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SnapshotUpdateKmsKeyRequest'->new($_) };

declare 'RepeatedSnapshotUpdateKmsKeyRequest',
    as ArrayRef[SnapshotUpdateKmsKeyRequest()];

coerce 'RepeatedSnapshotUpdateKmsKeyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SnapshotUpdateKmsKeyRequest'->new($_) } @$_ ] };

declare 'MapStringSnapshotUpdateKmsKeyRequest',
    as HashRef[SnapshotUpdateKmsKeyRequest()];

declare 'SourceDiskEncryptionKey',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SourceDiskEncryptionKey'];

coerce 'SourceDiskEncryptionKey',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SourceDiskEncryptionKey'->new($_) };

declare 'RepeatedSourceDiskEncryptionKey',
    as ArrayRef[SourceDiskEncryptionKey()];

coerce 'RepeatedSourceDiskEncryptionKey',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SourceDiskEncryptionKey'->new($_) } @$_ ] };

declare 'MapStringSourceDiskEncryptionKey',
    as HashRef[SourceDiskEncryptionKey()];

declare 'SourceInstanceParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SourceInstanceParams'];

coerce 'SourceInstanceParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SourceInstanceParams'->new($_) };

declare 'RepeatedSourceInstanceParams',
    as ArrayRef[SourceInstanceParams()];

coerce 'RepeatedSourceInstanceParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SourceInstanceParams'->new($_) } @$_ ] };

declare 'MapStringSourceInstanceParams',
    as HashRef[SourceInstanceParams()];

declare 'SourceInstanceProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SourceInstanceProperties'];

coerce 'SourceInstanceProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SourceInstanceProperties'->new($_) };

declare 'RepeatedSourceInstanceProperties',
    as ArrayRef[SourceInstanceProperties()];

coerce 'RepeatedSourceInstanceProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SourceInstanceProperties'->new($_) } @$_ ] };

declare 'MapStringSourceInstanceProperties',
    as HashRef[SourceInstanceProperties()];

declare 'KeyRevocationActionType',
    as (Int | Str);

declare 'PostKeyRevocationActionType',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SourceInstanceProperties::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SourceInstanceProperties::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SourceInstanceProperties::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'SslCertificate',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificate'];

coerce 'SslCertificate',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificate'->new($_) };

declare 'RepeatedSslCertificate',
    as ArrayRef[SslCertificate()];

coerce 'RepeatedSslCertificate',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificate'->new($_) } @$_ ] };

declare 'MapStringSslCertificate',
    as HashRef[SslCertificate()];

declare 'Type',
    as (Int | Str);

declare 'SslCertificateAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificateAggregatedList'];

coerce 'SslCertificateAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificateAggregatedList'->new($_) };

declare 'RepeatedSslCertificateAggregatedList',
    as ArrayRef[SslCertificateAggregatedList()];

coerce 'RepeatedSslCertificateAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificateAggregatedList'->new($_) } @$_ ] };

declare 'MapStringSslCertificateAggregatedList',
    as HashRef[SslCertificateAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificateAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificateAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificateAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'SslCertificateList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificateList'];

coerce 'SslCertificateList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificateList'->new($_) };

declare 'RepeatedSslCertificateList',
    as ArrayRef[SslCertificateList()];

coerce 'RepeatedSslCertificateList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificateList'->new($_) } @$_ ] };

declare 'MapStringSslCertificateList',
    as HashRef[SslCertificateList()];

declare 'SslCertificateManagedSslCertificate',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificateManagedSslCertificate'];

coerce 'SslCertificateManagedSslCertificate',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificateManagedSslCertificate'->new($_) };

declare 'RepeatedSslCertificateManagedSslCertificate',
    as ArrayRef[SslCertificateManagedSslCertificate()];

coerce 'RepeatedSslCertificateManagedSslCertificate',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificateManagedSslCertificate'->new($_) } @$_ ] };

declare 'MapStringSslCertificateManagedSslCertificate',
    as HashRef[SslCertificateManagedSslCertificate()];

declare 'Status',
    as (Int | Str);

declare 'DomainStatusEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificateManagedSslCertificate::DomainStatusEntry'];

coerce 'DomainStatusEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificateManagedSslCertificate::DomainStatusEntry'->new($_) };

declare 'RepeatedDomainStatusEntry',
    as ArrayRef[DomainStatusEntry()];

coerce 'RepeatedDomainStatusEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificateManagedSslCertificate::DomainStatusEntry'->new($_) } @$_ ] };

declare 'MapStringDomainStatusEntry',
    as HashRef[DomainStatusEntry()];

declare 'SslCertificateSelfManagedSslCertificate',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificateSelfManagedSslCertificate'];

coerce 'SslCertificateSelfManagedSslCertificate',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificateSelfManagedSslCertificate'->new($_) };

declare 'RepeatedSslCertificateSelfManagedSslCertificate',
    as ArrayRef[SslCertificateSelfManagedSslCertificate()];

coerce 'RepeatedSslCertificateSelfManagedSslCertificate',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificateSelfManagedSslCertificate'->new($_) } @$_ ] };

declare 'MapStringSslCertificateSelfManagedSslCertificate',
    as HashRef[SslCertificateSelfManagedSslCertificate()];

declare 'SslCertificatesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslCertificatesScopedList'];

coerce 'SslCertificatesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslCertificatesScopedList'->new($_) };

declare 'RepeatedSslCertificatesScopedList',
    as ArrayRef[SslCertificatesScopedList()];

coerce 'RepeatedSslCertificatesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslCertificatesScopedList'->new($_) } @$_ ] };

declare 'MapStringSslCertificatesScopedList',
    as HashRef[SslCertificatesScopedList()];

declare 'SslPoliciesAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslPoliciesAggregatedList'];

coerce 'SslPoliciesAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslPoliciesAggregatedList'->new($_) };

declare 'RepeatedSslPoliciesAggregatedList',
    as ArrayRef[SslPoliciesAggregatedList()];

coerce 'RepeatedSslPoliciesAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslPoliciesAggregatedList'->new($_) } @$_ ] };

declare 'MapStringSslPoliciesAggregatedList',
    as HashRef[SslPoliciesAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslPoliciesAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslPoliciesAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslPoliciesAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'SslPoliciesList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslPoliciesList'];

coerce 'SslPoliciesList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslPoliciesList'->new($_) };

declare 'RepeatedSslPoliciesList',
    as ArrayRef[SslPoliciesList()];

coerce 'RepeatedSslPoliciesList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslPoliciesList'->new($_) } @$_ ] };

declare 'MapStringSslPoliciesList',
    as HashRef[SslPoliciesList()];

declare 'SslPoliciesListAvailableFeaturesResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslPoliciesListAvailableFeaturesResponse'];

coerce 'SslPoliciesListAvailableFeaturesResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslPoliciesListAvailableFeaturesResponse'->new($_) };

declare 'RepeatedSslPoliciesListAvailableFeaturesResponse',
    as ArrayRef[SslPoliciesListAvailableFeaturesResponse()];

coerce 'RepeatedSslPoliciesListAvailableFeaturesResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslPoliciesListAvailableFeaturesResponse'->new($_) } @$_ ] };

declare 'MapStringSslPoliciesListAvailableFeaturesResponse',
    as HashRef[SslPoliciesListAvailableFeaturesResponse()];

declare 'SslPoliciesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslPoliciesScopedList'];

coerce 'SslPoliciesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslPoliciesScopedList'->new($_) };

declare 'RepeatedSslPoliciesScopedList',
    as ArrayRef[SslPoliciesScopedList()];

coerce 'RepeatedSslPoliciesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslPoliciesScopedList'->new($_) } @$_ ] };

declare 'MapStringSslPoliciesScopedList',
    as HashRef[SslPoliciesScopedList()];

declare 'SslPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslPolicy'];

coerce 'SslPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslPolicy'->new($_) };

declare 'RepeatedSslPolicy',
    as ArrayRef[SslPolicy()];

coerce 'RepeatedSslPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslPolicy'->new($_) } @$_ ] };

declare 'MapStringSslPolicy',
    as HashRef[SslPolicy()];

declare 'MinTlsVersion',
    as (Int | Str);

declare 'PostQuantumKeyExchange',
    as (Int | Str);

declare 'Profile',
    as (Int | Str);

declare 'SslPolicyReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SslPolicyReference'];

coerce 'SslPolicyReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SslPolicyReference'->new($_) };

declare 'RepeatedSslPolicyReference',
    as ArrayRef[SslPolicyReference()];

coerce 'RepeatedSslPolicyReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SslPolicyReference'->new($_) } @$_ ] };

declare 'MapStringSslPolicyReference',
    as HashRef[SslPolicyReference()];

declare 'StartAsyncReplicationDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StartAsyncReplicationDiskRequest'];

coerce 'StartAsyncReplicationDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StartAsyncReplicationDiskRequest'->new($_) };

declare 'RepeatedStartAsyncReplicationDiskRequest',
    as ArrayRef[StartAsyncReplicationDiskRequest()];

coerce 'RepeatedStartAsyncReplicationDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StartAsyncReplicationDiskRequest'->new($_) } @$_ ] };

declare 'MapStringStartAsyncReplicationDiskRequest',
    as HashRef[StartAsyncReplicationDiskRequest()];

declare 'StartAsyncReplicationRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StartAsyncReplicationRegionDiskRequest'];

coerce 'StartAsyncReplicationRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StartAsyncReplicationRegionDiskRequest'->new($_) };

declare 'RepeatedStartAsyncReplicationRegionDiskRequest',
    as ArrayRef[StartAsyncReplicationRegionDiskRequest()];

coerce 'RepeatedStartAsyncReplicationRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StartAsyncReplicationRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringStartAsyncReplicationRegionDiskRequest',
    as HashRef[StartAsyncReplicationRegionDiskRequest()];

declare 'StartInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StartInstanceRequest'];

coerce 'StartInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StartInstanceRequest'->new($_) };

declare 'RepeatedStartInstanceRequest',
    as ArrayRef[StartInstanceRequest()];

coerce 'RepeatedStartInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StartInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringStartInstanceRequest',
    as HashRef[StartInstanceRequest()];

declare 'StartInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StartInstancesInstanceGroupManagerRequest'];

coerce 'StartInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StartInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedStartInstancesInstanceGroupManagerRequest',
    as ArrayRef[StartInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedStartInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StartInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringStartInstancesInstanceGroupManagerRequest',
    as HashRef[StartInstancesInstanceGroupManagerRequest()];

declare 'StartInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StartInstancesRegionInstanceGroupManagerRequest'];

coerce 'StartInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StartInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedStartInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[StartInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedStartInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StartInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringStartInstancesRegionInstanceGroupManagerRequest',
    as HashRef[StartInstancesRegionInstanceGroupManagerRequest()];

declare 'StartWithEncryptionKeyInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StartWithEncryptionKeyInstanceRequest'];

coerce 'StartWithEncryptionKeyInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StartWithEncryptionKeyInstanceRequest'->new($_) };

declare 'RepeatedStartWithEncryptionKeyInstanceRequest',
    as ArrayRef[StartWithEncryptionKeyInstanceRequest()];

coerce 'RepeatedStartWithEncryptionKeyInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StartWithEncryptionKeyInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringStartWithEncryptionKeyInstanceRequest',
    as HashRef[StartWithEncryptionKeyInstanceRequest()];

declare 'StatefulPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StatefulPolicy'];

coerce 'StatefulPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StatefulPolicy'->new($_) };

declare 'RepeatedStatefulPolicy',
    as ArrayRef[StatefulPolicy()];

coerce 'RepeatedStatefulPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StatefulPolicy'->new($_) } @$_ ] };

declare 'MapStringStatefulPolicy',
    as HashRef[StatefulPolicy()];

declare 'StatefulPolicyPreservedState',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState'];

coerce 'StatefulPolicyPreservedState',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState'->new($_) };

declare 'RepeatedStatefulPolicyPreservedState',
    as ArrayRef[StatefulPolicyPreservedState()];

coerce 'RepeatedStatefulPolicyPreservedState',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState'->new($_) } @$_ ] };

declare 'MapStringStatefulPolicyPreservedState',
    as HashRef[StatefulPolicyPreservedState()];

declare 'DisksEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::DisksEntry'];

coerce 'DisksEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::DisksEntry'->new($_) };

declare 'RepeatedDisksEntry',
    as ArrayRef[DisksEntry()];

coerce 'RepeatedDisksEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::DisksEntry'->new($_) } @$_ ] };

declare 'MapStringDisksEntry',
    as HashRef[DisksEntry()];

declare 'ExternalIPsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::ExternalIPsEntry'];

coerce 'ExternalIPsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::ExternalIPsEntry'->new($_) };

declare 'RepeatedExternalIPsEntry',
    as ArrayRef[ExternalIPsEntry()];

coerce 'RepeatedExternalIPsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::ExternalIPsEntry'->new($_) } @$_ ] };

declare 'MapStringExternalIPsEntry',
    as HashRef[ExternalIPsEntry()];

declare 'InternalIPsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::InternalIPsEntry'];

coerce 'InternalIPsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::InternalIPsEntry'->new($_) };

declare 'RepeatedInternalIPsEntry',
    as ArrayRef[InternalIPsEntry()];

coerce 'RepeatedInternalIPsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedState::InternalIPsEntry'->new($_) } @$_ ] };

declare 'MapStringInternalIPsEntry',
    as HashRef[InternalIPsEntry()];

declare 'StatefulPolicyPreservedStateDiskDevice',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedStateDiskDevice'];

coerce 'StatefulPolicyPreservedStateDiskDevice',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedStateDiskDevice'->new($_) };

declare 'RepeatedStatefulPolicyPreservedStateDiskDevice',
    as ArrayRef[StatefulPolicyPreservedStateDiskDevice()];

coerce 'RepeatedStatefulPolicyPreservedStateDiskDevice',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedStateDiskDevice'->new($_) } @$_ ] };

declare 'MapStringStatefulPolicyPreservedStateDiskDevice',
    as HashRef[StatefulPolicyPreservedStateDiskDevice()];

declare 'AutoDelete',
    as (Int | Str);

declare 'StatefulPolicyPreservedStateNetworkIp',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedStateNetworkIp'];

coerce 'StatefulPolicyPreservedStateNetworkIp',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedStateNetworkIp'->new($_) };

declare 'RepeatedStatefulPolicyPreservedStateNetworkIp',
    as ArrayRef[StatefulPolicyPreservedStateNetworkIp()];

coerce 'RepeatedStatefulPolicyPreservedStateNetworkIp',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StatefulPolicyPreservedStateNetworkIp'->new($_) } @$_ ] };

declare 'MapStringStatefulPolicyPreservedStateNetworkIp',
    as HashRef[StatefulPolicyPreservedStateNetworkIp()];

declare 'AutoDelete',
    as (Int | Str);

declare 'Status',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Status'];

coerce 'Status',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Status'->new($_) };

declare 'RepeatedStatus',
    as ArrayRef[Status()];

coerce 'RepeatedStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Status'->new($_) } @$_ ] };

declare 'MapStringStatus',
    as HashRef[Status()];

declare 'StopAsyncReplicationDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StopAsyncReplicationDiskRequest'];

coerce 'StopAsyncReplicationDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StopAsyncReplicationDiskRequest'->new($_) };

declare 'RepeatedStopAsyncReplicationDiskRequest',
    as ArrayRef[StopAsyncReplicationDiskRequest()];

coerce 'RepeatedStopAsyncReplicationDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StopAsyncReplicationDiskRequest'->new($_) } @$_ ] };

declare 'MapStringStopAsyncReplicationDiskRequest',
    as HashRef[StopAsyncReplicationDiskRequest()];

declare 'StopAsyncReplicationRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StopAsyncReplicationRegionDiskRequest'];

coerce 'StopAsyncReplicationRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StopAsyncReplicationRegionDiskRequest'->new($_) };

declare 'RepeatedStopAsyncReplicationRegionDiskRequest',
    as ArrayRef[StopAsyncReplicationRegionDiskRequest()];

coerce 'RepeatedStopAsyncReplicationRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StopAsyncReplicationRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringStopAsyncReplicationRegionDiskRequest',
    as HashRef[StopAsyncReplicationRegionDiskRequest()];

declare 'StopGroupAsyncReplicationDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StopGroupAsyncReplicationDiskRequest'];

coerce 'StopGroupAsyncReplicationDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StopGroupAsyncReplicationDiskRequest'->new($_) };

declare 'RepeatedStopGroupAsyncReplicationDiskRequest',
    as ArrayRef[StopGroupAsyncReplicationDiskRequest()];

coerce 'RepeatedStopGroupAsyncReplicationDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StopGroupAsyncReplicationDiskRequest'->new($_) } @$_ ] };

declare 'MapStringStopGroupAsyncReplicationDiskRequest',
    as HashRef[StopGroupAsyncReplicationDiskRequest()];

declare 'StopGroupAsyncReplicationRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StopGroupAsyncReplicationRegionDiskRequest'];

coerce 'StopGroupAsyncReplicationRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StopGroupAsyncReplicationRegionDiskRequest'->new($_) };

declare 'RepeatedStopGroupAsyncReplicationRegionDiskRequest',
    as ArrayRef[StopGroupAsyncReplicationRegionDiskRequest()];

coerce 'RepeatedStopGroupAsyncReplicationRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StopGroupAsyncReplicationRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringStopGroupAsyncReplicationRegionDiskRequest',
    as HashRef[StopGroupAsyncReplicationRegionDiskRequest()];

declare 'StopInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StopInstanceRequest'];

coerce 'StopInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StopInstanceRequest'->new($_) };

declare 'RepeatedStopInstanceRequest',
    as ArrayRef[StopInstanceRequest()];

coerce 'RepeatedStopInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StopInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringStopInstanceRequest',
    as HashRef[StopInstanceRequest()];

declare 'StopInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StopInstancesInstanceGroupManagerRequest'];

coerce 'StopInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StopInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedStopInstancesInstanceGroupManagerRequest',
    as ArrayRef[StopInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedStopInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StopInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringStopInstancesInstanceGroupManagerRequest',
    as HashRef[StopInstancesInstanceGroupManagerRequest()];

declare 'StopInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StopInstancesRegionInstanceGroupManagerRequest'];

coerce 'StopInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StopInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedStopInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[StopInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedStopInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StopInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringStopInstancesRegionInstanceGroupManagerRequest',
    as HashRef[StopInstancesRegionInstanceGroupManagerRequest()];

declare 'StoragePool',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePool'];

coerce 'StoragePool',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePool'->new($_) };

declare 'RepeatedStoragePool',
    as ArrayRef[StoragePool()];

coerce 'RepeatedStoragePool',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePool'->new($_) } @$_ ] };

declare 'MapStringStoragePool',
    as HashRef[StoragePool()];

declare 'CapacityProvisioningType',
    as (Int | Str);

declare 'PerformanceProvisioningType',
    as (Int | Str);

declare 'State',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePool::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePool::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePool::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'StoragePoolAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolAggregatedList'];

coerce 'StoragePoolAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolAggregatedList'->new($_) };

declare 'RepeatedStoragePoolAggregatedList',
    as ArrayRef[StoragePoolAggregatedList()];

coerce 'RepeatedStoragePoolAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolAggregatedList'->new($_) } @$_ ] };

declare 'MapStringStoragePoolAggregatedList',
    as HashRef[StoragePoolAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'StoragePoolDisk',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolDisk'];

coerce 'StoragePoolDisk',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolDisk'->new($_) };

declare 'RepeatedStoragePoolDisk',
    as ArrayRef[StoragePoolDisk()];

coerce 'RepeatedStoragePoolDisk',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolDisk'->new($_) } @$_ ] };

declare 'MapStringStoragePoolDisk',
    as HashRef[StoragePoolDisk()];

declare 'Status',
    as (Int | Str);

declare 'StoragePoolExapoolProvisionedCapacityGb',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolExapoolProvisionedCapacityGb'];

coerce 'StoragePoolExapoolProvisionedCapacityGb',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolExapoolProvisionedCapacityGb'->new($_) };

declare 'RepeatedStoragePoolExapoolProvisionedCapacityGb',
    as ArrayRef[StoragePoolExapoolProvisionedCapacityGb()];

coerce 'RepeatedStoragePoolExapoolProvisionedCapacityGb',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolExapoolProvisionedCapacityGb'->new($_) } @$_ ] };

declare 'MapStringStoragePoolExapoolProvisionedCapacityGb',
    as HashRef[StoragePoolExapoolProvisionedCapacityGb()];

declare 'StoragePoolList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolList'];

coerce 'StoragePoolList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolList'->new($_) };

declare 'RepeatedStoragePoolList',
    as ArrayRef[StoragePoolList()];

coerce 'RepeatedStoragePoolList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolList'->new($_) } @$_ ] };

declare 'MapStringStoragePoolList',
    as HashRef[StoragePoolList()];

declare 'StoragePoolListDisks',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolListDisks'];

coerce 'StoragePoolListDisks',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolListDisks'->new($_) };

declare 'RepeatedStoragePoolListDisks',
    as ArrayRef[StoragePoolListDisks()];

coerce 'RepeatedStoragePoolListDisks',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolListDisks'->new($_) } @$_ ] };

declare 'MapStringStoragePoolListDisks',
    as HashRef[StoragePoolListDisks()];

declare 'StoragePoolParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolParams'];

coerce 'StoragePoolParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolParams'->new($_) };

declare 'RepeatedStoragePoolParams',
    as ArrayRef[StoragePoolParams()];

coerce 'RepeatedStoragePoolParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolParams'->new($_) } @$_ ] };

declare 'MapStringStoragePoolParams',
    as HashRef[StoragePoolParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'StoragePoolResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolResourceStatus'];

coerce 'StoragePoolResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolResourceStatus'->new($_) };

declare 'RepeatedStoragePoolResourceStatus',
    as ArrayRef[StoragePoolResourceStatus()];

coerce 'RepeatedStoragePoolResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolResourceStatus'->new($_) } @$_ ] };

declare 'MapStringStoragePoolResourceStatus',
    as HashRef[StoragePoolResourceStatus()];

declare 'StoragePoolType',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolType'];

coerce 'StoragePoolType',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolType'->new($_) };

declare 'RepeatedStoragePoolType',
    as ArrayRef[StoragePoolType()];

coerce 'RepeatedStoragePoolType',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolType'->new($_) } @$_ ] };

declare 'MapStringStoragePoolType',
    as HashRef[StoragePoolType()];

declare 'StoragePoolTypeAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolTypeAggregatedList'];

coerce 'StoragePoolTypeAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypeAggregatedList'->new($_) };

declare 'RepeatedStoragePoolTypeAggregatedList',
    as ArrayRef[StoragePoolTypeAggregatedList()];

coerce 'RepeatedStoragePoolTypeAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypeAggregatedList'->new($_) } @$_ ] };

declare 'MapStringStoragePoolTypeAggregatedList',
    as HashRef[StoragePoolTypeAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolTypeAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypeAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypeAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'StoragePoolTypeList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolTypeList'];

coerce 'StoragePoolTypeList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypeList'->new($_) };

declare 'RepeatedStoragePoolTypeList',
    as ArrayRef[StoragePoolTypeList()];

coerce 'RepeatedStoragePoolTypeList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypeList'->new($_) } @$_ ] };

declare 'MapStringStoragePoolTypeList',
    as HashRef[StoragePoolTypeList()];

declare 'StoragePoolTypesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolTypesScopedList'];

coerce 'StoragePoolTypesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypesScopedList'->new($_) };

declare 'RepeatedStoragePoolTypesScopedList',
    as ArrayRef[StoragePoolTypesScopedList()];

coerce 'RepeatedStoragePoolTypesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolTypesScopedList'->new($_) } @$_ ] };

declare 'MapStringStoragePoolTypesScopedList',
    as HashRef[StoragePoolTypesScopedList()];

declare 'StoragePoolsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::StoragePoolsScopedList'];

coerce 'StoragePoolsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::StoragePoolsScopedList'->new($_) };

declare 'RepeatedStoragePoolsScopedList',
    as ArrayRef[StoragePoolsScopedList()];

coerce 'RepeatedStoragePoolsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::StoragePoolsScopedList'->new($_) } @$_ ] };

declare 'MapStringStoragePoolsScopedList',
    as HashRef[StoragePoolsScopedList()];

declare 'Subnetwork',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Subnetwork'];

coerce 'Subnetwork',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Subnetwork'->new($_) };

declare 'RepeatedSubnetwork',
    as ArrayRef[Subnetwork()];

coerce 'RepeatedSubnetwork',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Subnetwork'->new($_) } @$_ ] };

declare 'MapStringSubnetwork',
    as HashRef[Subnetwork()];

declare 'Ipv6AccessType',
    as (Int | Str);

declare 'Ipv6GceEndpoint',
    as (Int | Str);

declare 'PrivateIpv6GoogleAccess',
    as (Int | Str);

declare 'Purpose',
    as (Int | Str);

declare 'ResolveSubnetMask',
    as (Int | Str);

declare 'Role',
    as (Int | Str);

declare 'StackType',
    as (Int | Str);

declare 'State',
    as (Int | Str);

declare 'SubnetworkAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkAggregatedList'];

coerce 'SubnetworkAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkAggregatedList'->new($_) };

declare 'RepeatedSubnetworkAggregatedList',
    as ArrayRef[SubnetworkAggregatedList()];

coerce 'RepeatedSubnetworkAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkAggregatedList'->new($_) } @$_ ] };

declare 'MapStringSubnetworkAggregatedList',
    as HashRef[SubnetworkAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'SubnetworkList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkList'];

coerce 'SubnetworkList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkList'->new($_) };

declare 'RepeatedSubnetworkList',
    as ArrayRef[SubnetworkList()];

coerce 'RepeatedSubnetworkList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkList'->new($_) } @$_ ] };

declare 'MapStringSubnetworkList',
    as HashRef[SubnetworkList()];

declare 'SubnetworkLogConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkLogConfig'];

coerce 'SubnetworkLogConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkLogConfig'->new($_) };

declare 'RepeatedSubnetworkLogConfig',
    as ArrayRef[SubnetworkLogConfig()];

coerce 'RepeatedSubnetworkLogConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkLogConfig'->new($_) } @$_ ] };

declare 'MapStringSubnetworkLogConfig',
    as HashRef[SubnetworkLogConfig()];

declare 'AggregationInterval',
    as (Int | Str);

declare 'Metadata',
    as (Int | Str);

declare 'SubnetworkParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkParams'];

coerce 'SubnetworkParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkParams'->new($_) };

declare 'RepeatedSubnetworkParams',
    as ArrayRef[SubnetworkParams()];

coerce 'RepeatedSubnetworkParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkParams'->new($_) } @$_ ] };

declare 'MapStringSubnetworkParams',
    as HashRef[SubnetworkParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'SubnetworkSecondaryRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkSecondaryRange'];

coerce 'SubnetworkSecondaryRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkSecondaryRange'->new($_) };

declare 'RepeatedSubnetworkSecondaryRange',
    as ArrayRef[SubnetworkSecondaryRange()];

coerce 'RepeatedSubnetworkSecondaryRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkSecondaryRange'->new($_) } @$_ ] };

declare 'MapStringSubnetworkSecondaryRange',
    as HashRef[SubnetworkSecondaryRange()];

declare 'IpVersion',
    as (Int | Str);

declare 'SubnetworkUtilizationDetails',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetails'];

coerce 'SubnetworkUtilizationDetails',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetails'->new($_) };

declare 'RepeatedSubnetworkUtilizationDetails',
    as ArrayRef[SubnetworkUtilizationDetails()];

coerce 'RepeatedSubnetworkUtilizationDetails',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetails'->new($_) } @$_ ] };

declare 'MapStringSubnetworkUtilizationDetails',
    as HashRef[SubnetworkUtilizationDetails()];

declare 'SubnetworkUtilizationDetailsIPV4Utilization',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetailsIPV4Utilization'];

coerce 'SubnetworkUtilizationDetailsIPV4Utilization',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetailsIPV4Utilization'->new($_) };

declare 'RepeatedSubnetworkUtilizationDetailsIPV4Utilization',
    as ArrayRef[SubnetworkUtilizationDetailsIPV4Utilization()];

coerce 'RepeatedSubnetworkUtilizationDetailsIPV4Utilization',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetailsIPV4Utilization'->new($_) } @$_ ] };

declare 'MapStringSubnetworkUtilizationDetailsIPV4Utilization',
    as HashRef[SubnetworkUtilizationDetailsIPV4Utilization()];

declare 'SubnetworkUtilizationDetailsIPV6Utilization',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetailsIPV6Utilization'];

coerce 'SubnetworkUtilizationDetailsIPV6Utilization',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetailsIPV6Utilization'->new($_) };

declare 'RepeatedSubnetworkUtilizationDetailsIPV6Utilization',
    as ArrayRef[SubnetworkUtilizationDetailsIPV6Utilization()];

coerce 'RepeatedSubnetworkUtilizationDetailsIPV6Utilization',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworkUtilizationDetailsIPV6Utilization'->new($_) } @$_ ] };

declare 'MapStringSubnetworkUtilizationDetailsIPV6Utilization',
    as HashRef[SubnetworkUtilizationDetailsIPV6Utilization()];

declare 'SubnetworksExpandIpCidrRangeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworksExpandIpCidrRangeRequest'];

coerce 'SubnetworksExpandIpCidrRangeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworksExpandIpCidrRangeRequest'->new($_) };

declare 'RepeatedSubnetworksExpandIpCidrRangeRequest',
    as ArrayRef[SubnetworksExpandIpCidrRangeRequest()];

coerce 'RepeatedSubnetworksExpandIpCidrRangeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworksExpandIpCidrRangeRequest'->new($_) } @$_ ] };

declare 'MapStringSubnetworksExpandIpCidrRangeRequest',
    as HashRef[SubnetworksExpandIpCidrRangeRequest()];

declare 'SubnetworksScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworksScopedList'];

coerce 'SubnetworksScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworksScopedList'->new($_) };

declare 'RepeatedSubnetworksScopedList',
    as ArrayRef[SubnetworksScopedList()];

coerce 'RepeatedSubnetworksScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworksScopedList'->new($_) } @$_ ] };

declare 'MapStringSubnetworksScopedList',
    as HashRef[SubnetworksScopedList()];

declare 'SubnetworksScopedWarning',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworksScopedWarning'];

coerce 'SubnetworksScopedWarning',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworksScopedWarning'->new($_) };

declare 'RepeatedSubnetworksScopedWarning',
    as ArrayRef[SubnetworksScopedWarning()];

coerce 'RepeatedSubnetworksScopedWarning',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworksScopedWarning'->new($_) } @$_ ] };

declare 'MapStringSubnetworksScopedWarning',
    as HashRef[SubnetworksScopedWarning()];

declare 'SubnetworksSetPrivateIpGoogleAccessRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SubnetworksSetPrivateIpGoogleAccessRequest'];

coerce 'SubnetworksSetPrivateIpGoogleAccessRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SubnetworksSetPrivateIpGoogleAccessRequest'->new($_) };

declare 'RepeatedSubnetworksSetPrivateIpGoogleAccessRequest',
    as ArrayRef[SubnetworksSetPrivateIpGoogleAccessRequest()];

coerce 'RepeatedSubnetworksSetPrivateIpGoogleAccessRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SubnetworksSetPrivateIpGoogleAccessRequest'->new($_) } @$_ ] };

declare 'MapStringSubnetworksSetPrivateIpGoogleAccessRequest',
    as HashRef[SubnetworksSetPrivateIpGoogleAccessRequest()];

declare 'Subsetting',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Subsetting'];

coerce 'Subsetting',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Subsetting'->new($_) };

declare 'RepeatedSubsetting',
    as ArrayRef[Subsetting()];

coerce 'RepeatedSubsetting',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Subsetting'->new($_) } @$_ ] };

declare 'MapStringSubsetting',
    as HashRef[Subsetting()];

declare 'Policy',
    as (Int | Str);

declare 'SuspendInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SuspendInstanceRequest'];

coerce 'SuspendInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SuspendInstanceRequest'->new($_) };

declare 'RepeatedSuspendInstanceRequest',
    as ArrayRef[SuspendInstanceRequest()];

coerce 'RepeatedSuspendInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SuspendInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringSuspendInstanceRequest',
    as HashRef[SuspendInstanceRequest()];

declare 'SuspendInstancesInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SuspendInstancesInstanceGroupManagerRequest'];

coerce 'SuspendInstancesInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SuspendInstancesInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedSuspendInstancesInstanceGroupManagerRequest',
    as ArrayRef[SuspendInstancesInstanceGroupManagerRequest()];

coerce 'RepeatedSuspendInstancesInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SuspendInstancesInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringSuspendInstancesInstanceGroupManagerRequest',
    as HashRef[SuspendInstancesInstanceGroupManagerRequest()];

declare 'SuspendInstancesRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SuspendInstancesRegionInstanceGroupManagerRequest'];

coerce 'SuspendInstancesRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SuspendInstancesRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedSuspendInstancesRegionInstanceGroupManagerRequest',
    as ArrayRef[SuspendInstancesRegionInstanceGroupManagerRequest()];

coerce 'RepeatedSuspendInstancesRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SuspendInstancesRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringSuspendInstancesRegionInstanceGroupManagerRequest',
    as HashRef[SuspendInstancesRegionInstanceGroupManagerRequest()];

declare 'SwitchToCustomModeNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::SwitchToCustomModeNetworkRequest'];

coerce 'SwitchToCustomModeNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::SwitchToCustomModeNetworkRequest'->new($_) };

declare 'RepeatedSwitchToCustomModeNetworkRequest',
    as ArrayRef[SwitchToCustomModeNetworkRequest()];

coerce 'RepeatedSwitchToCustomModeNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::SwitchToCustomModeNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringSwitchToCustomModeNetworkRequest',
    as HashRef[SwitchToCustomModeNetworkRequest()];

declare 'TCPHealthCheck',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TCPHealthCheck'];

coerce 'TCPHealthCheck',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TCPHealthCheck'->new($_) };

declare 'RepeatedTCPHealthCheck',
    as ArrayRef[TCPHealthCheck()];

coerce 'RepeatedTCPHealthCheck',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TCPHealthCheck'->new($_) } @$_ ] };

declare 'MapStringTCPHealthCheck',
    as HashRef[TCPHealthCheck()];

declare 'PortSpecification',
    as (Int | Str);

declare 'ProxyHeader',
    as (Int | Str);

declare 'Tags',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Tags'];

coerce 'Tags',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Tags'->new($_) };

declare 'RepeatedTags',
    as ArrayRef[Tags()];

coerce 'RepeatedTags',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Tags'->new($_) } @$_ ] };

declare 'MapStringTags',
    as HashRef[Tags()];

declare 'TargetGrpcProxy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetGrpcProxy'];

coerce 'TargetGrpcProxy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetGrpcProxy'->new($_) };

declare 'RepeatedTargetGrpcProxy',
    as ArrayRef[TargetGrpcProxy()];

coerce 'RepeatedTargetGrpcProxy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetGrpcProxy'->new($_) } @$_ ] };

declare 'MapStringTargetGrpcProxy',
    as HashRef[TargetGrpcProxy()];

declare 'TargetGrpcProxyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetGrpcProxyList'];

coerce 'TargetGrpcProxyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetGrpcProxyList'->new($_) };

declare 'RepeatedTargetGrpcProxyList',
    as ArrayRef[TargetGrpcProxyList()];

coerce 'RepeatedTargetGrpcProxyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetGrpcProxyList'->new($_) } @$_ ] };

declare 'MapStringTargetGrpcProxyList',
    as HashRef[TargetGrpcProxyList()];

declare 'TargetHttpProxiesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpProxiesScopedList'];

coerce 'TargetHttpProxiesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxiesScopedList'->new($_) };

declare 'RepeatedTargetHttpProxiesScopedList',
    as ArrayRef[TargetHttpProxiesScopedList()];

coerce 'RepeatedTargetHttpProxiesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxiesScopedList'->new($_) } @$_ ] };

declare 'MapStringTargetHttpProxiesScopedList',
    as HashRef[TargetHttpProxiesScopedList()];

declare 'TargetHttpProxy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpProxy'];

coerce 'TargetHttpProxy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxy'->new($_) };

declare 'RepeatedTargetHttpProxy',
    as ArrayRef[TargetHttpProxy()];

coerce 'RepeatedTargetHttpProxy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxy'->new($_) } @$_ ] };

declare 'MapStringTargetHttpProxy',
    as HashRef[TargetHttpProxy()];

declare 'TargetHttpProxyAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpProxyAggregatedList'];

coerce 'TargetHttpProxyAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxyAggregatedList'->new($_) };

declare 'RepeatedTargetHttpProxyAggregatedList',
    as ArrayRef[TargetHttpProxyAggregatedList()];

coerce 'RepeatedTargetHttpProxyAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxyAggregatedList'->new($_) } @$_ ] };

declare 'MapStringTargetHttpProxyAggregatedList',
    as HashRef[TargetHttpProxyAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpProxyAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxyAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxyAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'TargetHttpProxyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpProxyList'];

coerce 'TargetHttpProxyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxyList'->new($_) };

declare 'RepeatedTargetHttpProxyList',
    as ArrayRef[TargetHttpProxyList()];

coerce 'RepeatedTargetHttpProxyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpProxyList'->new($_) } @$_ ] };

declare 'MapStringTargetHttpProxyList',
    as HashRef[TargetHttpProxyList()];

declare 'TargetHttpsProxiesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesScopedList'];

coerce 'TargetHttpsProxiesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesScopedList'->new($_) };

declare 'RepeatedTargetHttpsProxiesScopedList',
    as ArrayRef[TargetHttpsProxiesScopedList()];

coerce 'RepeatedTargetHttpsProxiesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesScopedList'->new($_) } @$_ ] };

declare 'MapStringTargetHttpsProxiesScopedList',
    as HashRef[TargetHttpsProxiesScopedList()];

declare 'TargetHttpsProxiesSetCertificateMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetCertificateMapRequest'];

coerce 'TargetHttpsProxiesSetCertificateMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetCertificateMapRequest'->new($_) };

declare 'RepeatedTargetHttpsProxiesSetCertificateMapRequest',
    as ArrayRef[TargetHttpsProxiesSetCertificateMapRequest()];

coerce 'RepeatedTargetHttpsProxiesSetCertificateMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetCertificateMapRequest'->new($_) } @$_ ] };

declare 'MapStringTargetHttpsProxiesSetCertificateMapRequest',
    as HashRef[TargetHttpsProxiesSetCertificateMapRequest()];

declare 'TargetHttpsProxiesSetQuicOverrideRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetQuicOverrideRequest'];

coerce 'TargetHttpsProxiesSetQuicOverrideRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetQuicOverrideRequest'->new($_) };

declare 'RepeatedTargetHttpsProxiesSetQuicOverrideRequest',
    as ArrayRef[TargetHttpsProxiesSetQuicOverrideRequest()];

coerce 'RepeatedTargetHttpsProxiesSetQuicOverrideRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetQuicOverrideRequest'->new($_) } @$_ ] };

declare 'MapStringTargetHttpsProxiesSetQuicOverrideRequest',
    as HashRef[TargetHttpsProxiesSetQuicOverrideRequest()];

declare 'QuicOverride',
    as (Int | Str);

declare 'TargetHttpsProxiesSetSslCertificatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetSslCertificatesRequest'];

coerce 'TargetHttpsProxiesSetSslCertificatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetSslCertificatesRequest'->new($_) };

declare 'RepeatedTargetHttpsProxiesSetSslCertificatesRequest',
    as ArrayRef[TargetHttpsProxiesSetSslCertificatesRequest()];

coerce 'RepeatedTargetHttpsProxiesSetSslCertificatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxiesSetSslCertificatesRequest'->new($_) } @$_ ] };

declare 'MapStringTargetHttpsProxiesSetSslCertificatesRequest',
    as HashRef[TargetHttpsProxiesSetSslCertificatesRequest()];

declare 'TargetHttpsProxy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxy'];

coerce 'TargetHttpsProxy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxy'->new($_) };

declare 'RepeatedTargetHttpsProxy',
    as ArrayRef[TargetHttpsProxy()];

coerce 'RepeatedTargetHttpsProxy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxy'->new($_) } @$_ ] };

declare 'MapStringTargetHttpsProxy',
    as HashRef[TargetHttpsProxy()];

declare 'QuicOverride',
    as (Int | Str);

declare 'TlsEarlyData',
    as (Int | Str);

declare 'TargetHttpsProxyAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxyAggregatedList'];

coerce 'TargetHttpsProxyAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxyAggregatedList'->new($_) };

declare 'RepeatedTargetHttpsProxyAggregatedList',
    as ArrayRef[TargetHttpsProxyAggregatedList()];

coerce 'RepeatedTargetHttpsProxyAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxyAggregatedList'->new($_) } @$_ ] };

declare 'MapStringTargetHttpsProxyAggregatedList',
    as HashRef[TargetHttpsProxyAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxyAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxyAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxyAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'TargetHttpsProxyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetHttpsProxyList'];

coerce 'TargetHttpsProxyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxyList'->new($_) };

declare 'RepeatedTargetHttpsProxyList',
    as ArrayRef[TargetHttpsProxyList()];

coerce 'RepeatedTargetHttpsProxyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetHttpsProxyList'->new($_) } @$_ ] };

declare 'MapStringTargetHttpsProxyList',
    as HashRef[TargetHttpsProxyList()];

declare 'TargetInstance',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetInstance'];

coerce 'TargetInstance',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetInstance'->new($_) };

declare 'RepeatedTargetInstance',
    as ArrayRef[TargetInstance()];

coerce 'RepeatedTargetInstance',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetInstance'->new($_) } @$_ ] };

declare 'MapStringTargetInstance',
    as HashRef[TargetInstance()];

declare 'NatPolicy',
    as (Int | Str);

declare 'TargetInstanceAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetInstanceAggregatedList'];

coerce 'TargetInstanceAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetInstanceAggregatedList'->new($_) };

declare 'RepeatedTargetInstanceAggregatedList',
    as ArrayRef[TargetInstanceAggregatedList()];

coerce 'RepeatedTargetInstanceAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetInstanceAggregatedList'->new($_) } @$_ ] };

declare 'MapStringTargetInstanceAggregatedList',
    as HashRef[TargetInstanceAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetInstanceAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetInstanceAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetInstanceAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'TargetInstanceList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetInstanceList'];

coerce 'TargetInstanceList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetInstanceList'->new($_) };

declare 'RepeatedTargetInstanceList',
    as ArrayRef[TargetInstanceList()];

coerce 'RepeatedTargetInstanceList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetInstanceList'->new($_) } @$_ ] };

declare 'MapStringTargetInstanceList',
    as HashRef[TargetInstanceList()];

declare 'TargetInstancesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetInstancesScopedList'];

coerce 'TargetInstancesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetInstancesScopedList'->new($_) };

declare 'RepeatedTargetInstancesScopedList',
    as ArrayRef[TargetInstancesScopedList()];

coerce 'RepeatedTargetInstancesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetInstancesScopedList'->new($_) } @$_ ] };

declare 'MapStringTargetInstancesScopedList',
    as HashRef[TargetInstancesScopedList()];

declare 'TargetPool',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPool'];

coerce 'TargetPool',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPool'->new($_) };

declare 'RepeatedTargetPool',
    as ArrayRef[TargetPool()];

coerce 'RepeatedTargetPool',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPool'->new($_) } @$_ ] };

declare 'MapStringTargetPool',
    as HashRef[TargetPool()];

declare 'SessionAffinity',
    as (Int | Str);

declare 'TargetPoolAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolAggregatedList'];

coerce 'TargetPoolAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolAggregatedList'->new($_) };

declare 'RepeatedTargetPoolAggregatedList',
    as ArrayRef[TargetPoolAggregatedList()];

coerce 'RepeatedTargetPoolAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolAggregatedList'->new($_) } @$_ ] };

declare 'MapStringTargetPoolAggregatedList',
    as HashRef[TargetPoolAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'TargetPoolInstanceHealth',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolInstanceHealth'];

coerce 'TargetPoolInstanceHealth',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolInstanceHealth'->new($_) };

declare 'RepeatedTargetPoolInstanceHealth',
    as ArrayRef[TargetPoolInstanceHealth()];

coerce 'RepeatedTargetPoolInstanceHealth',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolInstanceHealth'->new($_) } @$_ ] };

declare 'MapStringTargetPoolInstanceHealth',
    as HashRef[TargetPoolInstanceHealth()];

declare 'TargetPoolList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolList'];

coerce 'TargetPoolList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolList'->new($_) };

declare 'RepeatedTargetPoolList',
    as ArrayRef[TargetPoolList()];

coerce 'RepeatedTargetPoolList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolList'->new($_) } @$_ ] };

declare 'MapStringTargetPoolList',
    as HashRef[TargetPoolList()];

declare 'TargetPoolsAddHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolsAddHealthCheckRequest'];

coerce 'TargetPoolsAddHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolsAddHealthCheckRequest'->new($_) };

declare 'RepeatedTargetPoolsAddHealthCheckRequest',
    as ArrayRef[TargetPoolsAddHealthCheckRequest()];

coerce 'RepeatedTargetPoolsAddHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolsAddHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringTargetPoolsAddHealthCheckRequest',
    as HashRef[TargetPoolsAddHealthCheckRequest()];

declare 'TargetPoolsAddInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolsAddInstanceRequest'];

coerce 'TargetPoolsAddInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolsAddInstanceRequest'->new($_) };

declare 'RepeatedTargetPoolsAddInstanceRequest',
    as ArrayRef[TargetPoolsAddInstanceRequest()];

coerce 'RepeatedTargetPoolsAddInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolsAddInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringTargetPoolsAddInstanceRequest',
    as HashRef[TargetPoolsAddInstanceRequest()];

declare 'TargetPoolsRemoveHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolsRemoveHealthCheckRequest'];

coerce 'TargetPoolsRemoveHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolsRemoveHealthCheckRequest'->new($_) };

declare 'RepeatedTargetPoolsRemoveHealthCheckRequest',
    as ArrayRef[TargetPoolsRemoveHealthCheckRequest()];

coerce 'RepeatedTargetPoolsRemoveHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolsRemoveHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringTargetPoolsRemoveHealthCheckRequest',
    as HashRef[TargetPoolsRemoveHealthCheckRequest()];

declare 'TargetPoolsRemoveInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolsRemoveInstanceRequest'];

coerce 'TargetPoolsRemoveInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolsRemoveInstanceRequest'->new($_) };

declare 'RepeatedTargetPoolsRemoveInstanceRequest',
    as ArrayRef[TargetPoolsRemoveInstanceRequest()];

coerce 'RepeatedTargetPoolsRemoveInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolsRemoveInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringTargetPoolsRemoveInstanceRequest',
    as HashRef[TargetPoolsRemoveInstanceRequest()];

declare 'TargetPoolsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetPoolsScopedList'];

coerce 'TargetPoolsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetPoolsScopedList'->new($_) };

declare 'RepeatedTargetPoolsScopedList',
    as ArrayRef[TargetPoolsScopedList()];

coerce 'RepeatedTargetPoolsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetPoolsScopedList'->new($_) } @$_ ] };

declare 'MapStringTargetPoolsScopedList',
    as HashRef[TargetPoolsScopedList()];

declare 'TargetReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetReference'];

coerce 'TargetReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetReference'->new($_) };

declare 'RepeatedTargetReference',
    as ArrayRef[TargetReference()];

coerce 'RepeatedTargetReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetReference'->new($_) } @$_ ] };

declare 'MapStringTargetReference',
    as HashRef[TargetReference()];

declare 'TargetSslProxiesSetBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetBackendServiceRequest'];

coerce 'TargetSslProxiesSetBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetBackendServiceRequest'->new($_) };

declare 'RepeatedTargetSslProxiesSetBackendServiceRequest',
    as ArrayRef[TargetSslProxiesSetBackendServiceRequest()];

coerce 'RepeatedTargetSslProxiesSetBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringTargetSslProxiesSetBackendServiceRequest',
    as HashRef[TargetSslProxiesSetBackendServiceRequest()];

declare 'TargetSslProxiesSetCertificateMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetCertificateMapRequest'];

coerce 'TargetSslProxiesSetCertificateMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetCertificateMapRequest'->new($_) };

declare 'RepeatedTargetSslProxiesSetCertificateMapRequest',
    as ArrayRef[TargetSslProxiesSetCertificateMapRequest()];

coerce 'RepeatedTargetSslProxiesSetCertificateMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetCertificateMapRequest'->new($_) } @$_ ] };

declare 'MapStringTargetSslProxiesSetCertificateMapRequest',
    as HashRef[TargetSslProxiesSetCertificateMapRequest()];

declare 'TargetSslProxiesSetProxyHeaderRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetProxyHeaderRequest'];

coerce 'TargetSslProxiesSetProxyHeaderRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetProxyHeaderRequest'->new($_) };

declare 'RepeatedTargetSslProxiesSetProxyHeaderRequest',
    as ArrayRef[TargetSslProxiesSetProxyHeaderRequest()];

coerce 'RepeatedTargetSslProxiesSetProxyHeaderRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetProxyHeaderRequest'->new($_) } @$_ ] };

declare 'MapStringTargetSslProxiesSetProxyHeaderRequest',
    as HashRef[TargetSslProxiesSetProxyHeaderRequest()];

declare 'ProxyHeader',
    as (Int | Str);

declare 'TargetSslProxiesSetSslCertificatesRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetSslCertificatesRequest'];

coerce 'TargetSslProxiesSetSslCertificatesRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetSslCertificatesRequest'->new($_) };

declare 'RepeatedTargetSslProxiesSetSslCertificatesRequest',
    as ArrayRef[TargetSslProxiesSetSslCertificatesRequest()];

coerce 'RepeatedTargetSslProxiesSetSslCertificatesRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetSslProxiesSetSslCertificatesRequest'->new($_) } @$_ ] };

declare 'MapStringTargetSslProxiesSetSslCertificatesRequest',
    as HashRef[TargetSslProxiesSetSslCertificatesRequest()];

declare 'TargetSslProxy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetSslProxy'];

coerce 'TargetSslProxy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetSslProxy'->new($_) };

declare 'RepeatedTargetSslProxy',
    as ArrayRef[TargetSslProxy()];

coerce 'RepeatedTargetSslProxy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetSslProxy'->new($_) } @$_ ] };

declare 'MapStringTargetSslProxy',
    as HashRef[TargetSslProxy()];

declare 'ProxyHeader',
    as (Int | Str);

declare 'TargetSslProxyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetSslProxyList'];

coerce 'TargetSslProxyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetSslProxyList'->new($_) };

declare 'RepeatedTargetSslProxyList',
    as ArrayRef[TargetSslProxyList()];

coerce 'RepeatedTargetSslProxyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetSslProxyList'->new($_) } @$_ ] };

declare 'MapStringTargetSslProxyList',
    as HashRef[TargetSslProxyList()];

declare 'TargetTcpProxiesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetTcpProxiesScopedList'];

coerce 'TargetTcpProxiesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxiesScopedList'->new($_) };

declare 'RepeatedTargetTcpProxiesScopedList',
    as ArrayRef[TargetTcpProxiesScopedList()];

coerce 'RepeatedTargetTcpProxiesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxiesScopedList'->new($_) } @$_ ] };

declare 'MapStringTargetTcpProxiesScopedList',
    as HashRef[TargetTcpProxiesScopedList()];

declare 'TargetTcpProxiesSetBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetTcpProxiesSetBackendServiceRequest'];

coerce 'TargetTcpProxiesSetBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxiesSetBackendServiceRequest'->new($_) };

declare 'RepeatedTargetTcpProxiesSetBackendServiceRequest',
    as ArrayRef[TargetTcpProxiesSetBackendServiceRequest()];

coerce 'RepeatedTargetTcpProxiesSetBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxiesSetBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringTargetTcpProxiesSetBackendServiceRequest',
    as HashRef[TargetTcpProxiesSetBackendServiceRequest()];

declare 'TargetTcpProxiesSetProxyHeaderRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetTcpProxiesSetProxyHeaderRequest'];

coerce 'TargetTcpProxiesSetProxyHeaderRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxiesSetProxyHeaderRequest'->new($_) };

declare 'RepeatedTargetTcpProxiesSetProxyHeaderRequest',
    as ArrayRef[TargetTcpProxiesSetProxyHeaderRequest()];

coerce 'RepeatedTargetTcpProxiesSetProxyHeaderRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxiesSetProxyHeaderRequest'->new($_) } @$_ ] };

declare 'MapStringTargetTcpProxiesSetProxyHeaderRequest',
    as HashRef[TargetTcpProxiesSetProxyHeaderRequest()];

declare 'ProxyHeader',
    as (Int | Str);

declare 'TargetTcpProxy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetTcpProxy'];

coerce 'TargetTcpProxy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxy'->new($_) };

declare 'RepeatedTargetTcpProxy',
    as ArrayRef[TargetTcpProxy()];

coerce 'RepeatedTargetTcpProxy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxy'->new($_) } @$_ ] };

declare 'MapStringTargetTcpProxy',
    as HashRef[TargetTcpProxy()];

declare 'LoadBalancingScheme',
    as (Int | Str);

declare 'ProxyHeader',
    as (Int | Str);

declare 'TargetTcpProxyAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetTcpProxyAggregatedList'];

coerce 'TargetTcpProxyAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxyAggregatedList'->new($_) };

declare 'RepeatedTargetTcpProxyAggregatedList',
    as ArrayRef[TargetTcpProxyAggregatedList()];

coerce 'RepeatedTargetTcpProxyAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxyAggregatedList'->new($_) } @$_ ] };

declare 'MapStringTargetTcpProxyAggregatedList',
    as HashRef[TargetTcpProxyAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetTcpProxyAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxyAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxyAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'TargetTcpProxyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetTcpProxyList'];

coerce 'TargetTcpProxyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxyList'->new($_) };

declare 'RepeatedTargetTcpProxyList',
    as ArrayRef[TargetTcpProxyList()];

coerce 'RepeatedTargetTcpProxyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetTcpProxyList'->new($_) } @$_ ] };

declare 'MapStringTargetTcpProxyList',
    as HashRef[TargetTcpProxyList()];

declare 'TargetVpnGateway',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGateway'];

coerce 'TargetVpnGateway',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGateway'->new($_) };

declare 'RepeatedTargetVpnGateway',
    as ArrayRef[TargetVpnGateway()];

coerce 'RepeatedTargetVpnGateway',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGateway'->new($_) } @$_ ] };

declare 'MapStringTargetVpnGateway',
    as HashRef[TargetVpnGateway()];

declare 'Status',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGateway::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGateway::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGateway::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'TargetVpnGatewayAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGatewayAggregatedList'];

coerce 'TargetVpnGatewayAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayAggregatedList'->new($_) };

declare 'RepeatedTargetVpnGatewayAggregatedList',
    as ArrayRef[TargetVpnGatewayAggregatedList()];

coerce 'RepeatedTargetVpnGatewayAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayAggregatedList'->new($_) } @$_ ] };

declare 'MapStringTargetVpnGatewayAggregatedList',
    as HashRef[TargetVpnGatewayAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGatewayAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'TargetVpnGatewayList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGatewayList'];

coerce 'TargetVpnGatewayList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayList'->new($_) };

declare 'RepeatedTargetVpnGatewayList',
    as ArrayRef[TargetVpnGatewayList()];

coerce 'RepeatedTargetVpnGatewayList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayList'->new($_) } @$_ ] };

declare 'MapStringTargetVpnGatewayList',
    as HashRef[TargetVpnGatewayList()];

declare 'TargetVpnGatewayParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGatewayParams'];

coerce 'TargetVpnGatewayParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayParams'->new($_) };

declare 'RepeatedTargetVpnGatewayParams',
    as ArrayRef[TargetVpnGatewayParams()];

coerce 'RepeatedTargetVpnGatewayParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayParams'->new($_) } @$_ ] };

declare 'MapStringTargetVpnGatewayParams',
    as HashRef[TargetVpnGatewayParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGatewayParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewayParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'TargetVpnGatewaysScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TargetVpnGatewaysScopedList'];

coerce 'TargetVpnGatewaysScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewaysScopedList'->new($_) };

declare 'RepeatedTargetVpnGatewaysScopedList',
    as ArrayRef[TargetVpnGatewaysScopedList()];

coerce 'RepeatedTargetVpnGatewaysScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TargetVpnGatewaysScopedList'->new($_) } @$_ ] };

declare 'MapStringTargetVpnGatewaysScopedList',
    as HashRef[TargetVpnGatewaysScopedList()];

declare 'TestFailure',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestFailure'];

coerce 'TestFailure',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestFailure'->new($_) };

declare 'RepeatedTestFailure',
    as ArrayRef[TestFailure()];

coerce 'RepeatedTestFailure',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestFailure'->new($_) } @$_ ] };

declare 'MapStringTestFailure',
    as HashRef[TestFailure()];

declare 'TestIamPermissionsAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsAddressRequest'];

coerce 'TestIamPermissionsAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsAddressRequest'->new($_) };

declare 'RepeatedTestIamPermissionsAddressRequest',
    as ArrayRef[TestIamPermissionsAddressRequest()];

coerce 'RepeatedTestIamPermissionsAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsAddressRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsAddressRequest',
    as HashRef[TestIamPermissionsAddressRequest()];

declare 'TestIamPermissionsAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsAutoscalerRequest'];

coerce 'TestIamPermissionsAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsAutoscalerRequest'->new($_) };

declare 'RepeatedTestIamPermissionsAutoscalerRequest',
    as ArrayRef[TestIamPermissionsAutoscalerRequest()];

coerce 'RepeatedTestIamPermissionsAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsAutoscalerRequest',
    as HashRef[TestIamPermissionsAutoscalerRequest()];

declare 'TestIamPermissionsBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsBackendBucketRequest'];

coerce 'TestIamPermissionsBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsBackendBucketRequest'->new($_) };

declare 'RepeatedTestIamPermissionsBackendBucketRequest',
    as ArrayRef[TestIamPermissionsBackendBucketRequest()];

coerce 'RepeatedTestIamPermissionsBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsBackendBucketRequest',
    as HashRef[TestIamPermissionsBackendBucketRequest()];

declare 'TestIamPermissionsBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsBackendServiceRequest'];

coerce 'TestIamPermissionsBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsBackendServiceRequest'->new($_) };

declare 'RepeatedTestIamPermissionsBackendServiceRequest',
    as ArrayRef[TestIamPermissionsBackendServiceRequest()];

coerce 'RepeatedTestIamPermissionsBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsBackendServiceRequest',
    as HashRef[TestIamPermissionsBackendServiceRequest()];

declare 'TestIamPermissionsDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsDiskRequest'];

coerce 'TestIamPermissionsDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsDiskRequest'->new($_) };

declare 'RepeatedTestIamPermissionsDiskRequest',
    as ArrayRef[TestIamPermissionsDiskRequest()];

coerce 'RepeatedTestIamPermissionsDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsDiskRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsDiskRequest',
    as HashRef[TestIamPermissionsDiskRequest()];

declare 'TestIamPermissionsExternalVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsExternalVpnGatewayRequest'];

coerce 'TestIamPermissionsExternalVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsExternalVpnGatewayRequest'->new($_) };

declare 'RepeatedTestIamPermissionsExternalVpnGatewayRequest',
    as ArrayRef[TestIamPermissionsExternalVpnGatewayRequest()];

coerce 'RepeatedTestIamPermissionsExternalVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsExternalVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsExternalVpnGatewayRequest',
    as HashRef[TestIamPermissionsExternalVpnGatewayRequest()];

declare 'TestIamPermissionsFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsFirewallPolicyRequest'];

coerce 'TestIamPermissionsFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsFirewallPolicyRequest'->new($_) };

declare 'RepeatedTestIamPermissionsFirewallPolicyRequest',
    as ArrayRef[TestIamPermissionsFirewallPolicyRequest()];

coerce 'RepeatedTestIamPermissionsFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsFirewallPolicyRequest',
    as HashRef[TestIamPermissionsFirewallPolicyRequest()];

declare 'TestIamPermissionsFirewallRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsFirewallRequest'];

coerce 'TestIamPermissionsFirewallRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsFirewallRequest'->new($_) };

declare 'RepeatedTestIamPermissionsFirewallRequest',
    as ArrayRef[TestIamPermissionsFirewallRequest()];

coerce 'RepeatedTestIamPermissionsFirewallRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsFirewallRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsFirewallRequest',
    as HashRef[TestIamPermissionsFirewallRequest()];

declare 'TestIamPermissionsGlobalAddressRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsGlobalAddressRequest'];

coerce 'TestIamPermissionsGlobalAddressRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsGlobalAddressRequest'->new($_) };

declare 'RepeatedTestIamPermissionsGlobalAddressRequest',
    as ArrayRef[TestIamPermissionsGlobalAddressRequest()];

coerce 'RepeatedTestIamPermissionsGlobalAddressRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsGlobalAddressRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsGlobalAddressRequest',
    as HashRef[TestIamPermissionsGlobalAddressRequest()];

declare 'TestIamPermissionsHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsHealthCheckRequest'];

coerce 'TestIamPermissionsHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsHealthCheckRequest'->new($_) };

declare 'RepeatedTestIamPermissionsHealthCheckRequest',
    as ArrayRef[TestIamPermissionsHealthCheckRequest()];

coerce 'RepeatedTestIamPermissionsHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsHealthCheckRequest',
    as HashRef[TestIamPermissionsHealthCheckRequest()];

declare 'TestIamPermissionsImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsImageRequest'];

coerce 'TestIamPermissionsImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsImageRequest'->new($_) };

declare 'RepeatedTestIamPermissionsImageRequest',
    as ArrayRef[TestIamPermissionsImageRequest()];

coerce 'RepeatedTestIamPermissionsImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsImageRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsImageRequest',
    as HashRef[TestIamPermissionsImageRequest()];

declare 'TestIamPermissionsInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceGroupRequest'];

coerce 'TestIamPermissionsInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsInstanceGroupRequest',
    as ArrayRef[TestIamPermissionsInstanceGroupRequest()];

coerce 'RepeatedTestIamPermissionsInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsInstanceGroupRequest',
    as HashRef[TestIamPermissionsInstanceGroupRequest()];

declare 'TestIamPermissionsInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceRequest'];

coerce 'TestIamPermissionsInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceRequest'->new($_) };

declare 'RepeatedTestIamPermissionsInstanceRequest',
    as ArrayRef[TestIamPermissionsInstanceRequest()];

coerce 'RepeatedTestIamPermissionsInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsInstanceRequest',
    as HashRef[TestIamPermissionsInstanceRequest()];

declare 'TestIamPermissionsInstanceTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceTemplateRequest'];

coerce 'TestIamPermissionsInstanceTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceTemplateRequest'->new($_) };

declare 'RepeatedTestIamPermissionsInstanceTemplateRequest',
    as ArrayRef[TestIamPermissionsInstanceTemplateRequest()];

coerce 'RepeatedTestIamPermissionsInstanceTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstanceTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsInstanceTemplateRequest',
    as HashRef[TestIamPermissionsInstanceTemplateRequest()];

declare 'TestIamPermissionsInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstantSnapshotGroupRequest'];

coerce 'TestIamPermissionsInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsInstantSnapshotGroupRequest',
    as ArrayRef[TestIamPermissionsInstantSnapshotGroupRequest()];

coerce 'RepeatedTestIamPermissionsInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsInstantSnapshotGroupRequest',
    as HashRef[TestIamPermissionsInstantSnapshotGroupRequest()];

declare 'TestIamPermissionsInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstantSnapshotRequest'];

coerce 'TestIamPermissionsInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstantSnapshotRequest'->new($_) };

declare 'RepeatedTestIamPermissionsInstantSnapshotRequest',
    as ArrayRef[TestIamPermissionsInstantSnapshotRequest()];

coerce 'RepeatedTestIamPermissionsInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsInstantSnapshotRequest',
    as HashRef[TestIamPermissionsInstantSnapshotRequest()];

declare 'TestIamPermissionsInterconnectAttachmentGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsInterconnectAttachmentGroupRequest'];

coerce 'TestIamPermissionsInterconnectAttachmentGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInterconnectAttachmentGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsInterconnectAttachmentGroupRequest',
    as ArrayRef[TestIamPermissionsInterconnectAttachmentGroupRequest()];

coerce 'RepeatedTestIamPermissionsInterconnectAttachmentGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInterconnectAttachmentGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsInterconnectAttachmentGroupRequest',
    as HashRef[TestIamPermissionsInterconnectAttachmentGroupRequest()];

declare 'TestIamPermissionsInterconnectGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsInterconnectGroupRequest'];

coerce 'TestIamPermissionsInterconnectGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInterconnectGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsInterconnectGroupRequest',
    as ArrayRef[TestIamPermissionsInterconnectGroupRequest()];

coerce 'RepeatedTestIamPermissionsInterconnectGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsInterconnectGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsInterconnectGroupRequest',
    as HashRef[TestIamPermissionsInterconnectGroupRequest()];

declare 'TestIamPermissionsLicenseCodeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsLicenseCodeRequest'];

coerce 'TestIamPermissionsLicenseCodeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsLicenseCodeRequest'->new($_) };

declare 'RepeatedTestIamPermissionsLicenseCodeRequest',
    as ArrayRef[TestIamPermissionsLicenseCodeRequest()];

coerce 'RepeatedTestIamPermissionsLicenseCodeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsLicenseCodeRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsLicenseCodeRequest',
    as HashRef[TestIamPermissionsLicenseCodeRequest()];

declare 'TestIamPermissionsLicenseRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsLicenseRequest'];

coerce 'TestIamPermissionsLicenseRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsLicenseRequest'->new($_) };

declare 'RepeatedTestIamPermissionsLicenseRequest',
    as ArrayRef[TestIamPermissionsLicenseRequest()];

coerce 'RepeatedTestIamPermissionsLicenseRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsLicenseRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsLicenseRequest',
    as HashRef[TestIamPermissionsLicenseRequest()];

declare 'TestIamPermissionsMachineImageRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsMachineImageRequest'];

coerce 'TestIamPermissionsMachineImageRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsMachineImageRequest'->new($_) };

declare 'RepeatedTestIamPermissionsMachineImageRequest',
    as ArrayRef[TestIamPermissionsMachineImageRequest()];

coerce 'RepeatedTestIamPermissionsMachineImageRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsMachineImageRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsMachineImageRequest',
    as HashRef[TestIamPermissionsMachineImageRequest()];

declare 'TestIamPermissionsNetworkAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkAttachmentRequest'];

coerce 'TestIamPermissionsNetworkAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkAttachmentRequest'->new($_) };

declare 'RepeatedTestIamPermissionsNetworkAttachmentRequest',
    as ArrayRef[TestIamPermissionsNetworkAttachmentRequest()];

coerce 'RepeatedTestIamPermissionsNetworkAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsNetworkAttachmentRequest',
    as HashRef[TestIamPermissionsNetworkAttachmentRequest()];

declare 'TestIamPermissionsNetworkEndpointGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkEndpointGroupRequest'];

coerce 'TestIamPermissionsNetworkEndpointGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkEndpointGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsNetworkEndpointGroupRequest',
    as ArrayRef[TestIamPermissionsNetworkEndpointGroupRequest()];

coerce 'RepeatedTestIamPermissionsNetworkEndpointGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkEndpointGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsNetworkEndpointGroupRequest',
    as HashRef[TestIamPermissionsNetworkEndpointGroupRequest()];

declare 'TestIamPermissionsNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkFirewallPolicyRequest'];

coerce 'TestIamPermissionsNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedTestIamPermissionsNetworkFirewallPolicyRequest',
    as ArrayRef[TestIamPermissionsNetworkFirewallPolicyRequest()];

coerce 'RepeatedTestIamPermissionsNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsNetworkFirewallPolicyRequest',
    as HashRef[TestIamPermissionsNetworkFirewallPolicyRequest()];

declare 'TestIamPermissionsNodeGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsNodeGroupRequest'];

coerce 'TestIamPermissionsNodeGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNodeGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsNodeGroupRequest',
    as ArrayRef[TestIamPermissionsNodeGroupRequest()];

coerce 'RepeatedTestIamPermissionsNodeGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNodeGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsNodeGroupRequest',
    as HashRef[TestIamPermissionsNodeGroupRequest()];

declare 'TestIamPermissionsNodeTemplateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsNodeTemplateRequest'];

coerce 'TestIamPermissionsNodeTemplateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNodeTemplateRequest'->new($_) };

declare 'RepeatedTestIamPermissionsNodeTemplateRequest',
    as ArrayRef[TestIamPermissionsNodeTemplateRequest()];

coerce 'RepeatedTestIamPermissionsNodeTemplateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsNodeTemplateRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsNodeTemplateRequest',
    as HashRef[TestIamPermissionsNodeTemplateRequest()];

declare 'TestIamPermissionsPacketMirroringRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsPacketMirroringRequest'];

coerce 'TestIamPermissionsPacketMirroringRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsPacketMirroringRequest'->new($_) };

declare 'RepeatedTestIamPermissionsPacketMirroringRequest',
    as ArrayRef[TestIamPermissionsPacketMirroringRequest()];

coerce 'RepeatedTestIamPermissionsPacketMirroringRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsPacketMirroringRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsPacketMirroringRequest',
    as HashRef[TestIamPermissionsPacketMirroringRequest()];

declare 'TestIamPermissionsRegionAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionAutoscalerRequest'];

coerce 'TestIamPermissionsRegionAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionAutoscalerRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionAutoscalerRequest',
    as ArrayRef[TestIamPermissionsRegionAutoscalerRequest()];

coerce 'RepeatedTestIamPermissionsRegionAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionAutoscalerRequest',
    as HashRef[TestIamPermissionsRegionAutoscalerRequest()];

declare 'TestIamPermissionsRegionBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionBackendBucketRequest'];

coerce 'TestIamPermissionsRegionBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionBackendBucketRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionBackendBucketRequest',
    as ArrayRef[TestIamPermissionsRegionBackendBucketRequest()];

coerce 'RepeatedTestIamPermissionsRegionBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionBackendBucketRequest',
    as HashRef[TestIamPermissionsRegionBackendBucketRequest()];

declare 'TestIamPermissionsRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionBackendServiceRequest'];

coerce 'TestIamPermissionsRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionBackendServiceRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionBackendServiceRequest',
    as ArrayRef[TestIamPermissionsRegionBackendServiceRequest()];

coerce 'RepeatedTestIamPermissionsRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionBackendServiceRequest',
    as HashRef[TestIamPermissionsRegionBackendServiceRequest()];

declare 'TestIamPermissionsRegionCompositeHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionCompositeHealthCheckRequest'];

coerce 'TestIamPermissionsRegionCompositeHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionCompositeHealthCheckRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionCompositeHealthCheckRequest',
    as ArrayRef[TestIamPermissionsRegionCompositeHealthCheckRequest()];

coerce 'RepeatedTestIamPermissionsRegionCompositeHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionCompositeHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionCompositeHealthCheckRequest',
    as HashRef[TestIamPermissionsRegionCompositeHealthCheckRequest()];

declare 'TestIamPermissionsRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionDiskRequest'];

coerce 'TestIamPermissionsRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionDiskRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionDiskRequest',
    as ArrayRef[TestIamPermissionsRegionDiskRequest()];

coerce 'RepeatedTestIamPermissionsRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionDiskRequest',
    as HashRef[TestIamPermissionsRegionDiskRequest()];

declare 'TestIamPermissionsRegionHealthAggregationPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthAggregationPolicyRequest'];

coerce 'TestIamPermissionsRegionHealthAggregationPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthAggregationPolicyRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionHealthAggregationPolicyRequest',
    as ArrayRef[TestIamPermissionsRegionHealthAggregationPolicyRequest()];

coerce 'RepeatedTestIamPermissionsRegionHealthAggregationPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthAggregationPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionHealthAggregationPolicyRequest',
    as HashRef[TestIamPermissionsRegionHealthAggregationPolicyRequest()];

declare 'TestIamPermissionsRegionHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthCheckRequest'];

coerce 'TestIamPermissionsRegionHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthCheckRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionHealthCheckRequest',
    as ArrayRef[TestIamPermissionsRegionHealthCheckRequest()];

coerce 'RepeatedTestIamPermissionsRegionHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionHealthCheckRequest',
    as HashRef[TestIamPermissionsRegionHealthCheckRequest()];

declare 'TestIamPermissionsRegionHealthCheckServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthCheckServiceRequest'];

coerce 'TestIamPermissionsRegionHealthCheckServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthCheckServiceRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionHealthCheckServiceRequest',
    as ArrayRef[TestIamPermissionsRegionHealthCheckServiceRequest()];

coerce 'RepeatedTestIamPermissionsRegionHealthCheckServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthCheckServiceRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionHealthCheckServiceRequest',
    as HashRef[TestIamPermissionsRegionHealthCheckServiceRequest()];

declare 'TestIamPermissionsRegionHealthSourceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthSourceRequest'];

coerce 'TestIamPermissionsRegionHealthSourceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthSourceRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionHealthSourceRequest',
    as ArrayRef[TestIamPermissionsRegionHealthSourceRequest()];

coerce 'RepeatedTestIamPermissionsRegionHealthSourceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionHealthSourceRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionHealthSourceRequest',
    as HashRef[TestIamPermissionsRegionHealthSourceRequest()];

declare 'TestIamPermissionsRegionInstanceGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstanceGroupRequest'];

coerce 'TestIamPermissionsRegionInstanceGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstanceGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionInstanceGroupRequest',
    as ArrayRef[TestIamPermissionsRegionInstanceGroupRequest()];

coerce 'RepeatedTestIamPermissionsRegionInstanceGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstanceGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionInstanceGroupRequest',
    as HashRef[TestIamPermissionsRegionInstanceGroupRequest()];

declare 'TestIamPermissionsRegionInstantSnapshotGroupRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstantSnapshotGroupRequest'];

coerce 'TestIamPermissionsRegionInstantSnapshotGroupRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstantSnapshotGroupRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionInstantSnapshotGroupRequest',
    as ArrayRef[TestIamPermissionsRegionInstantSnapshotGroupRequest()];

coerce 'RepeatedTestIamPermissionsRegionInstantSnapshotGroupRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstantSnapshotGroupRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionInstantSnapshotGroupRequest',
    as HashRef[TestIamPermissionsRegionInstantSnapshotGroupRequest()];

declare 'TestIamPermissionsRegionInstantSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstantSnapshotRequest'];

coerce 'TestIamPermissionsRegionInstantSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstantSnapshotRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionInstantSnapshotRequest',
    as ArrayRef[TestIamPermissionsRegionInstantSnapshotRequest()];

coerce 'RepeatedTestIamPermissionsRegionInstantSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionInstantSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionInstantSnapshotRequest',
    as HashRef[TestIamPermissionsRegionInstantSnapshotRequest()];

declare 'TestIamPermissionsRegionNetworkFirewallPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionNetworkFirewallPolicyRequest'];

coerce 'TestIamPermissionsRegionNetworkFirewallPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionNetworkFirewallPolicyRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionNetworkFirewallPolicyRequest',
    as ArrayRef[TestIamPermissionsRegionNetworkFirewallPolicyRequest()];

coerce 'RepeatedTestIamPermissionsRegionNetworkFirewallPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionNetworkFirewallPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionNetworkFirewallPolicyRequest',
    as HashRef[TestIamPermissionsRegionNetworkFirewallPolicyRequest()];

declare 'TestIamPermissionsRegionNotificationEndpointRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionNotificationEndpointRequest'];

coerce 'TestIamPermissionsRegionNotificationEndpointRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionNotificationEndpointRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionNotificationEndpointRequest',
    as ArrayRef[TestIamPermissionsRegionNotificationEndpointRequest()];

coerce 'RepeatedTestIamPermissionsRegionNotificationEndpointRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionNotificationEndpointRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionNotificationEndpointRequest',
    as HashRef[TestIamPermissionsRegionNotificationEndpointRequest()];

declare 'TestIamPermissionsRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionSnapshotRequest'];

coerce 'TestIamPermissionsRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionSnapshotRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRegionSnapshotRequest',
    as ArrayRef[TestIamPermissionsRegionSnapshotRequest()];

coerce 'RepeatedTestIamPermissionsRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRegionSnapshotRequest',
    as HashRef[TestIamPermissionsRegionSnapshotRequest()];

declare 'TestIamPermissionsReservationBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationBlockRequest'];

coerce 'TestIamPermissionsReservationBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationBlockRequest'->new($_) };

declare 'RepeatedTestIamPermissionsReservationBlockRequest',
    as ArrayRef[TestIamPermissionsReservationBlockRequest()];

coerce 'RepeatedTestIamPermissionsReservationBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationBlockRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsReservationBlockRequest',
    as HashRef[TestIamPermissionsReservationBlockRequest()];

declare 'TestIamPermissionsReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationRequest'];

coerce 'TestIamPermissionsReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationRequest'->new($_) };

declare 'RepeatedTestIamPermissionsReservationRequest',
    as ArrayRef[TestIamPermissionsReservationRequest()];

coerce 'RepeatedTestIamPermissionsReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsReservationRequest',
    as HashRef[TestIamPermissionsReservationRequest()];

declare 'TestIamPermissionsReservationSubBlockRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationSubBlockRequest'];

coerce 'TestIamPermissionsReservationSubBlockRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationSubBlockRequest'->new($_) };

declare 'RepeatedTestIamPermissionsReservationSubBlockRequest',
    as ArrayRef[TestIamPermissionsReservationSubBlockRequest()];

coerce 'RepeatedTestIamPermissionsReservationSubBlockRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsReservationSubBlockRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsReservationSubBlockRequest',
    as HashRef[TestIamPermissionsReservationSubBlockRequest()];

declare 'TestIamPermissionsResourcePolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsResourcePolicyRequest'];

coerce 'TestIamPermissionsResourcePolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsResourcePolicyRequest'->new($_) };

declare 'RepeatedTestIamPermissionsResourcePolicyRequest',
    as ArrayRef[TestIamPermissionsResourcePolicyRequest()];

coerce 'RepeatedTestIamPermissionsResourcePolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsResourcePolicyRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsResourcePolicyRequest',
    as HashRef[TestIamPermissionsResourcePolicyRequest()];

declare 'TestIamPermissionsRouteRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsRouteRequest'];

coerce 'TestIamPermissionsRouteRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRouteRequest'->new($_) };

declare 'RepeatedTestIamPermissionsRouteRequest',
    as ArrayRef[TestIamPermissionsRouteRequest()];

coerce 'RepeatedTestIamPermissionsRouteRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsRouteRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsRouteRequest',
    as HashRef[TestIamPermissionsRouteRequest()];

declare 'TestIamPermissionsServiceAttachmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsServiceAttachmentRequest'];

coerce 'TestIamPermissionsServiceAttachmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsServiceAttachmentRequest'->new($_) };

declare 'RepeatedTestIamPermissionsServiceAttachmentRequest',
    as ArrayRef[TestIamPermissionsServiceAttachmentRequest()];

coerce 'RepeatedTestIamPermissionsServiceAttachmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsServiceAttachmentRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsServiceAttachmentRequest',
    as HashRef[TestIamPermissionsServiceAttachmentRequest()];

declare 'TestIamPermissionsSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsSnapshotRequest'];

coerce 'TestIamPermissionsSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsSnapshotRequest'->new($_) };

declare 'RepeatedTestIamPermissionsSnapshotRequest',
    as ArrayRef[TestIamPermissionsSnapshotRequest()];

coerce 'RepeatedTestIamPermissionsSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsSnapshotRequest',
    as HashRef[TestIamPermissionsSnapshotRequest()];

declare 'TestIamPermissionsStoragePoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsStoragePoolRequest'];

coerce 'TestIamPermissionsStoragePoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsStoragePoolRequest'->new($_) };

declare 'RepeatedTestIamPermissionsStoragePoolRequest',
    as ArrayRef[TestIamPermissionsStoragePoolRequest()];

coerce 'RepeatedTestIamPermissionsStoragePoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsStoragePoolRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsStoragePoolRequest',
    as HashRef[TestIamPermissionsStoragePoolRequest()];

declare 'TestIamPermissionsSubnetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsSubnetworkRequest'];

coerce 'TestIamPermissionsSubnetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsSubnetworkRequest'->new($_) };

declare 'RepeatedTestIamPermissionsSubnetworkRequest',
    as ArrayRef[TestIamPermissionsSubnetworkRequest()];

coerce 'RepeatedTestIamPermissionsSubnetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsSubnetworkRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsSubnetworkRequest',
    as HashRef[TestIamPermissionsSubnetworkRequest()];

declare 'TestIamPermissionsTargetInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetInstanceRequest'];

coerce 'TestIamPermissionsTargetInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetInstanceRequest'->new($_) };

declare 'RepeatedTestIamPermissionsTargetInstanceRequest',
    as ArrayRef[TestIamPermissionsTargetInstanceRequest()];

coerce 'RepeatedTestIamPermissionsTargetInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsTargetInstanceRequest',
    as HashRef[TestIamPermissionsTargetInstanceRequest()];

declare 'TestIamPermissionsTargetPoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetPoolRequest'];

coerce 'TestIamPermissionsTargetPoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetPoolRequest'->new($_) };

declare 'RepeatedTestIamPermissionsTargetPoolRequest',
    as ArrayRef[TestIamPermissionsTargetPoolRequest()];

coerce 'RepeatedTestIamPermissionsTargetPoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetPoolRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsTargetPoolRequest',
    as HashRef[TestIamPermissionsTargetPoolRequest()];

declare 'TestIamPermissionsTargetSslProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetSslProxyRequest'];

coerce 'TestIamPermissionsTargetSslProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetSslProxyRequest'->new($_) };

declare 'RepeatedTestIamPermissionsTargetSslProxyRequest',
    as ArrayRef[TestIamPermissionsTargetSslProxyRequest()];

coerce 'RepeatedTestIamPermissionsTargetSslProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetSslProxyRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsTargetSslProxyRequest',
    as HashRef[TestIamPermissionsTargetSslProxyRequest()];

declare 'TestIamPermissionsTargetTcpProxyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetTcpProxyRequest'];

coerce 'TestIamPermissionsTargetTcpProxyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetTcpProxyRequest'->new($_) };

declare 'RepeatedTestIamPermissionsTargetTcpProxyRequest',
    as ArrayRef[TestIamPermissionsTargetTcpProxyRequest()];

coerce 'RepeatedTestIamPermissionsTargetTcpProxyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsTargetTcpProxyRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsTargetTcpProxyRequest',
    as HashRef[TestIamPermissionsTargetTcpProxyRequest()];

declare 'TestIamPermissionsUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsUrlMapRequest'];

coerce 'TestIamPermissionsUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsUrlMapRequest'->new($_) };

declare 'RepeatedTestIamPermissionsUrlMapRequest',
    as ArrayRef[TestIamPermissionsUrlMapRequest()];

coerce 'RepeatedTestIamPermissionsUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsUrlMapRequest',
    as HashRef[TestIamPermissionsUrlMapRequest()];

declare 'TestIamPermissionsVpnGatewayRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestIamPermissionsVpnGatewayRequest'];

coerce 'TestIamPermissionsVpnGatewayRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsVpnGatewayRequest'->new($_) };

declare 'RepeatedTestIamPermissionsVpnGatewayRequest',
    as ArrayRef[TestIamPermissionsVpnGatewayRequest()];

coerce 'RepeatedTestIamPermissionsVpnGatewayRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestIamPermissionsVpnGatewayRequest'->new($_) } @$_ ] };

declare 'MapStringTestIamPermissionsVpnGatewayRequest',
    as HashRef[TestIamPermissionsVpnGatewayRequest()];

declare 'TestPermissionsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestPermissionsRequest'];

coerce 'TestPermissionsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestPermissionsRequest'->new($_) };

declare 'RepeatedTestPermissionsRequest',
    as ArrayRef[TestPermissionsRequest()];

coerce 'RepeatedTestPermissionsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestPermissionsRequest'->new($_) } @$_ ] };

declare 'MapStringTestPermissionsRequest',
    as HashRef[TestPermissionsRequest()];

declare 'TestPermissionsResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TestPermissionsResponse'];

coerce 'TestPermissionsResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TestPermissionsResponse'->new($_) };

declare 'RepeatedTestPermissionsResponse',
    as ArrayRef[TestPermissionsResponse()];

coerce 'RepeatedTestPermissionsResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TestPermissionsResponse'->new($_) } @$_ ] };

declare 'MapStringTestPermissionsResponse',
    as HashRef[TestPermissionsResponse()];

declare 'TimeZone',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::TimeZone'];

coerce 'TimeZone',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::TimeZone'->new($_) };

declare 'RepeatedTimeZone',
    as ArrayRef[TimeZone()];

coerce 'RepeatedTimeZone',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::TimeZone'->new($_) } @$_ ] };

declare 'MapStringTimeZone',
    as HashRef[TimeZone()];

declare 'Uint128',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Uint128'];

coerce 'Uint128',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Uint128'->new($_) };

declare 'RepeatedUint128',
    as ArrayRef[Uint128()];

coerce 'RepeatedUint128',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Uint128'->new($_) } @$_ ] };

declare 'MapStringUint128',
    as HashRef[Uint128()];

declare 'UpcomingMaintenance',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpcomingMaintenance'];

coerce 'UpcomingMaintenance',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpcomingMaintenance'->new($_) };

declare 'RepeatedUpcomingMaintenance',
    as ArrayRef[UpcomingMaintenance()];

coerce 'RepeatedUpcomingMaintenance',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpcomingMaintenance'->new($_) } @$_ ] };

declare 'MapStringUpcomingMaintenance',
    as HashRef[UpcomingMaintenance()];

declare 'MaintenanceReasons',
    as (Int | Str);

declare 'MaintenanceStatus',
    as (Int | Str);

declare 'Type',
    as (Int | Str);

declare 'UpdateAccessConfigInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateAccessConfigInstanceRequest'];

coerce 'UpdateAccessConfigInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateAccessConfigInstanceRequest'->new($_) };

declare 'RepeatedUpdateAccessConfigInstanceRequest',
    as ArrayRef[UpdateAccessConfigInstanceRequest()];

coerce 'RepeatedUpdateAccessConfigInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateAccessConfigInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateAccessConfigInstanceRequest',
    as HashRef[UpdateAccessConfigInstanceRequest()];

declare 'UpdateAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateAutoscalerRequest'];

coerce 'UpdateAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateAutoscalerRequest'->new($_) };

declare 'RepeatedUpdateAutoscalerRequest',
    as ArrayRef[UpdateAutoscalerRequest()];

coerce 'RepeatedUpdateAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateAutoscalerRequest',
    as HashRef[UpdateAutoscalerRequest()];

declare 'UpdateBackendBucketRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateBackendBucketRequest'];

coerce 'UpdateBackendBucketRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateBackendBucketRequest'->new($_) };

declare 'RepeatedUpdateBackendBucketRequest',
    as ArrayRef[UpdateBackendBucketRequest()];

coerce 'RepeatedUpdateBackendBucketRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateBackendBucketRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateBackendBucketRequest',
    as HashRef[UpdateBackendBucketRequest()];

declare 'UpdateBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateBackendServiceRequest'];

coerce 'UpdateBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateBackendServiceRequest'->new($_) };

declare 'RepeatedUpdateBackendServiceRequest',
    as ArrayRef[UpdateBackendServiceRequest()];

coerce 'RepeatedUpdateBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateBackendServiceRequest',
    as HashRef[UpdateBackendServiceRequest()];

declare 'UpdateDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateDiskRequest'];

coerce 'UpdateDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateDiskRequest'->new($_) };

declare 'RepeatedUpdateDiskRequest',
    as ArrayRef[UpdateDiskRequest()];

coerce 'RepeatedUpdateDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateDiskRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateDiskRequest',
    as HashRef[UpdateDiskRequest()];

declare 'UpdateDisplayDeviceInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateDisplayDeviceInstanceRequest'];

coerce 'UpdateDisplayDeviceInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateDisplayDeviceInstanceRequest'->new($_) };

declare 'RepeatedUpdateDisplayDeviceInstanceRequest',
    as ArrayRef[UpdateDisplayDeviceInstanceRequest()];

coerce 'RepeatedUpdateDisplayDeviceInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateDisplayDeviceInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateDisplayDeviceInstanceRequest',
    as HashRef[UpdateDisplayDeviceInstanceRequest()];

declare 'UpdateFirewallRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateFirewallRequest'];

coerce 'UpdateFirewallRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateFirewallRequest'->new($_) };

declare 'RepeatedUpdateFirewallRequest',
    as ArrayRef[UpdateFirewallRequest()];

coerce 'RepeatedUpdateFirewallRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateFirewallRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateFirewallRequest',
    as HashRef[UpdateFirewallRequest()];

declare 'UpdateFutureReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateFutureReservationRequest'];

coerce 'UpdateFutureReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateFutureReservationRequest'->new($_) };

declare 'RepeatedUpdateFutureReservationRequest',
    as ArrayRef[UpdateFutureReservationRequest()];

coerce 'RepeatedUpdateFutureReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateFutureReservationRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateFutureReservationRequest',
    as HashRef[UpdateFutureReservationRequest()];

declare 'UpdateGlobalVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateGlobalVmExtensionPolicyRequest'];

coerce 'UpdateGlobalVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateGlobalVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedUpdateGlobalVmExtensionPolicyRequest',
    as ArrayRef[UpdateGlobalVmExtensionPolicyRequest()];

coerce 'RepeatedUpdateGlobalVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateGlobalVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateGlobalVmExtensionPolicyRequest',
    as HashRef[UpdateGlobalVmExtensionPolicyRequest()];

declare 'UpdateHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateHealthCheckRequest'];

coerce 'UpdateHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateHealthCheckRequest'->new($_) };

declare 'RepeatedUpdateHealthCheckRequest',
    as ArrayRef[UpdateHealthCheckRequest()];

coerce 'RepeatedUpdateHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateHealthCheckRequest',
    as HashRef[UpdateHealthCheckRequest()];

declare 'UpdateInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateInstanceRequest'];

coerce 'UpdateInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateInstanceRequest'->new($_) };

declare 'RepeatedUpdateInstanceRequest',
    as ArrayRef[UpdateInstanceRequest()];

coerce 'RepeatedUpdateInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateInstanceRequest',
    as HashRef[UpdateInstanceRequest()];

declare 'MinimalAction',
    as (Int | Str);

declare 'MostDisruptiveAllowedAction',
    as (Int | Str);

declare 'UpdateKmsKeyDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateKmsKeyDiskRequest'];

coerce 'UpdateKmsKeyDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeyDiskRequest'->new($_) };

declare 'RepeatedUpdateKmsKeyDiskRequest',
    as ArrayRef[UpdateKmsKeyDiskRequest()];

coerce 'RepeatedUpdateKmsKeyDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeyDiskRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateKmsKeyDiskRequest',
    as HashRef[UpdateKmsKeyDiskRequest()];

declare 'UpdateKmsKeyRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateKmsKeyRegionDiskRequest'];

coerce 'UpdateKmsKeyRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeyRegionDiskRequest'->new($_) };

declare 'RepeatedUpdateKmsKeyRegionDiskRequest',
    as ArrayRef[UpdateKmsKeyRegionDiskRequest()];

coerce 'RepeatedUpdateKmsKeyRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeyRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateKmsKeyRegionDiskRequest',
    as HashRef[UpdateKmsKeyRegionDiskRequest()];

declare 'UpdateKmsKeyRegionSnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateKmsKeyRegionSnapshotRequest'];

coerce 'UpdateKmsKeyRegionSnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeyRegionSnapshotRequest'->new($_) };

declare 'RepeatedUpdateKmsKeyRegionSnapshotRequest',
    as ArrayRef[UpdateKmsKeyRegionSnapshotRequest()];

coerce 'RepeatedUpdateKmsKeyRegionSnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeyRegionSnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateKmsKeyRegionSnapshotRequest',
    as HashRef[UpdateKmsKeyRegionSnapshotRequest()];

declare 'UpdateKmsKeySnapshotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateKmsKeySnapshotRequest'];

coerce 'UpdateKmsKeySnapshotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeySnapshotRequest'->new($_) };

declare 'RepeatedUpdateKmsKeySnapshotRequest',
    as ArrayRef[UpdateKmsKeySnapshotRequest()];

coerce 'RepeatedUpdateKmsKeySnapshotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateKmsKeySnapshotRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateKmsKeySnapshotRequest',
    as HashRef[UpdateKmsKeySnapshotRequest()];

declare 'UpdateLicenseRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateLicenseRequest'];

coerce 'UpdateLicenseRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateLicenseRequest'->new($_) };

declare 'RepeatedUpdateLicenseRequest',
    as ArrayRef[UpdateLicenseRequest()];

coerce 'RepeatedUpdateLicenseRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateLicenseRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateLicenseRequest',
    as HashRef[UpdateLicenseRequest()];

declare 'UpdateNamedSetRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateNamedSetRouterRequest'];

coerce 'UpdateNamedSetRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateNamedSetRouterRequest'->new($_) };

declare 'RepeatedUpdateNamedSetRouterRequest',
    as ArrayRef[UpdateNamedSetRouterRequest()];

coerce 'RepeatedUpdateNamedSetRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateNamedSetRouterRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateNamedSetRouterRequest',
    as HashRef[UpdateNamedSetRouterRequest()];

declare 'UpdateNetworkInterfaceInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateNetworkInterfaceInstanceRequest'];

coerce 'UpdateNetworkInterfaceInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateNetworkInterfaceInstanceRequest'->new($_) };

declare 'RepeatedUpdateNetworkInterfaceInstanceRequest',
    as ArrayRef[UpdateNetworkInterfaceInstanceRequest()];

coerce 'RepeatedUpdateNetworkInterfaceInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateNetworkInterfaceInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateNetworkInterfaceInstanceRequest',
    as HashRef[UpdateNetworkInterfaceInstanceRequest()];

declare 'UpdatePeeringNetworkRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdatePeeringNetworkRequest'];

coerce 'UpdatePeeringNetworkRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdatePeeringNetworkRequest'->new($_) };

declare 'RepeatedUpdatePeeringNetworkRequest',
    as ArrayRef[UpdatePeeringNetworkRequest()];

coerce 'RepeatedUpdatePeeringNetworkRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdatePeeringNetworkRequest'->new($_) } @$_ ] };

declare 'MapStringUpdatePeeringNetworkRequest',
    as HashRef[UpdatePeeringNetworkRequest()];

declare 'UpdatePerInstanceConfigsInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdatePerInstanceConfigsInstanceGroupManagerRequest'];

coerce 'UpdatePerInstanceConfigsInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdatePerInstanceConfigsInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedUpdatePerInstanceConfigsInstanceGroupManagerRequest',
    as ArrayRef[UpdatePerInstanceConfigsInstanceGroupManagerRequest()];

coerce 'RepeatedUpdatePerInstanceConfigsInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdatePerInstanceConfigsInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringUpdatePerInstanceConfigsInstanceGroupManagerRequest',
    as HashRef[UpdatePerInstanceConfigsInstanceGroupManagerRequest()];

declare 'UpdatePerInstanceConfigsRegionInstanceGroupManagerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdatePerInstanceConfigsRegionInstanceGroupManagerRequest'];

coerce 'UpdatePerInstanceConfigsRegionInstanceGroupManagerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdatePerInstanceConfigsRegionInstanceGroupManagerRequest'->new($_) };

declare 'RepeatedUpdatePerInstanceConfigsRegionInstanceGroupManagerRequest',
    as ArrayRef[UpdatePerInstanceConfigsRegionInstanceGroupManagerRequest()];

coerce 'RepeatedUpdatePerInstanceConfigsRegionInstanceGroupManagerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdatePerInstanceConfigsRegionInstanceGroupManagerRequest'->new($_) } @$_ ] };

declare 'MapStringUpdatePerInstanceConfigsRegionInstanceGroupManagerRequest',
    as HashRef[UpdatePerInstanceConfigsRegionInstanceGroupManagerRequest()];

declare 'UpdatePreviewFeatureRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdatePreviewFeatureRequest'];

coerce 'UpdatePreviewFeatureRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdatePreviewFeatureRequest'->new($_) };

declare 'RepeatedUpdatePreviewFeatureRequest',
    as ArrayRef[UpdatePreviewFeatureRequest()];

coerce 'RepeatedUpdatePreviewFeatureRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdatePreviewFeatureRequest'->new($_) } @$_ ] };

declare 'MapStringUpdatePreviewFeatureRequest',
    as HashRef[UpdatePreviewFeatureRequest()];

declare 'UpdateRegionAutoscalerRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRegionAutoscalerRequest'];

coerce 'UpdateRegionAutoscalerRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRegionAutoscalerRequest'->new($_) };

declare 'RepeatedUpdateRegionAutoscalerRequest',
    as ArrayRef[UpdateRegionAutoscalerRequest()];

coerce 'RepeatedUpdateRegionAutoscalerRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRegionAutoscalerRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRegionAutoscalerRequest',
    as HashRef[UpdateRegionAutoscalerRequest()];

declare 'UpdateRegionBackendServiceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRegionBackendServiceRequest'];

coerce 'UpdateRegionBackendServiceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRegionBackendServiceRequest'->new($_) };

declare 'RepeatedUpdateRegionBackendServiceRequest',
    as ArrayRef[UpdateRegionBackendServiceRequest()];

coerce 'RepeatedUpdateRegionBackendServiceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRegionBackendServiceRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRegionBackendServiceRequest',
    as HashRef[UpdateRegionBackendServiceRequest()];

declare 'UpdateRegionCommitmentRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRegionCommitmentRequest'];

coerce 'UpdateRegionCommitmentRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRegionCommitmentRequest'->new($_) };

declare 'RepeatedUpdateRegionCommitmentRequest',
    as ArrayRef[UpdateRegionCommitmentRequest()];

coerce 'RepeatedUpdateRegionCommitmentRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRegionCommitmentRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRegionCommitmentRequest',
    as HashRef[UpdateRegionCommitmentRequest()];

declare 'UpdateRegionDiskRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRegionDiskRequest'];

coerce 'UpdateRegionDiskRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRegionDiskRequest'->new($_) };

declare 'RepeatedUpdateRegionDiskRequest',
    as ArrayRef[UpdateRegionDiskRequest()];

coerce 'RepeatedUpdateRegionDiskRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRegionDiskRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRegionDiskRequest',
    as HashRef[UpdateRegionDiskRequest()];

declare 'UpdateRegionHealthCheckRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRegionHealthCheckRequest'];

coerce 'UpdateRegionHealthCheckRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRegionHealthCheckRequest'->new($_) };

declare 'RepeatedUpdateRegionHealthCheckRequest',
    as ArrayRef[UpdateRegionHealthCheckRequest()];

coerce 'RepeatedUpdateRegionHealthCheckRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRegionHealthCheckRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRegionHealthCheckRequest',
    as HashRef[UpdateRegionHealthCheckRequest()];

declare 'UpdateRegionUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRegionUrlMapRequest'];

coerce 'UpdateRegionUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRegionUrlMapRequest'->new($_) };

declare 'RepeatedUpdateRegionUrlMapRequest',
    as ArrayRef[UpdateRegionUrlMapRequest()];

coerce 'RepeatedUpdateRegionUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRegionUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRegionUrlMapRequest',
    as HashRef[UpdateRegionUrlMapRequest()];

declare 'UpdateReservationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateReservationRequest'];

coerce 'UpdateReservationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateReservationRequest'->new($_) };

declare 'RepeatedUpdateReservationRequest',
    as ArrayRef[UpdateReservationRequest()];

coerce 'RepeatedUpdateReservationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateReservationRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateReservationRequest',
    as HashRef[UpdateReservationRequest()];

declare 'UpdateReservationSlotRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateReservationSlotRequest'];

coerce 'UpdateReservationSlotRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateReservationSlotRequest'->new($_) };

declare 'RepeatedUpdateReservationSlotRequest',
    as ArrayRef[UpdateReservationSlotRequest()];

coerce 'RepeatedUpdateReservationSlotRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateReservationSlotRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateReservationSlotRequest',
    as HashRef[UpdateReservationSlotRequest()];

declare 'UpdateRoutePolicyRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRoutePolicyRouterRequest'];

coerce 'UpdateRoutePolicyRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRoutePolicyRouterRequest'->new($_) };

declare 'RepeatedUpdateRoutePolicyRouterRequest',
    as ArrayRef[UpdateRoutePolicyRouterRequest()];

coerce 'RepeatedUpdateRoutePolicyRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRoutePolicyRouterRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRoutePolicyRouterRequest',
    as HashRef[UpdateRoutePolicyRouterRequest()];

declare 'UpdateRouterRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateRouterRequest'];

coerce 'UpdateRouterRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateRouterRequest'->new($_) };

declare 'RepeatedUpdateRouterRequest',
    as ArrayRef[UpdateRouterRequest()];

coerce 'RepeatedUpdateRouterRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateRouterRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateRouterRequest',
    as HashRef[UpdateRouterRequest()];

declare 'UpdateShieldedInstanceConfigInstanceRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateShieldedInstanceConfigInstanceRequest'];

coerce 'UpdateShieldedInstanceConfigInstanceRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateShieldedInstanceConfigInstanceRequest'->new($_) };

declare 'RepeatedUpdateShieldedInstanceConfigInstanceRequest',
    as ArrayRef[UpdateShieldedInstanceConfigInstanceRequest()];

coerce 'RepeatedUpdateShieldedInstanceConfigInstanceRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateShieldedInstanceConfigInstanceRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateShieldedInstanceConfigInstanceRequest',
    as HashRef[UpdateShieldedInstanceConfigInstanceRequest()];

declare 'UpdateStoragePoolRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateStoragePoolRequest'];

coerce 'UpdateStoragePoolRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateStoragePoolRequest'->new($_) };

declare 'RepeatedUpdateStoragePoolRequest',
    as ArrayRef[UpdateStoragePoolRequest()];

coerce 'RepeatedUpdateStoragePoolRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateStoragePoolRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateStoragePoolRequest',
    as HashRef[UpdateStoragePoolRequest()];

declare 'UpdateUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateUrlMapRequest'];

coerce 'UpdateUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateUrlMapRequest'->new($_) };

declare 'RepeatedUpdateUrlMapRequest',
    as ArrayRef[UpdateUrlMapRequest()];

coerce 'RepeatedUpdateUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateUrlMapRequest',
    as HashRef[UpdateUrlMapRequest()];

declare 'UpdateZoneVmExtensionPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UpdateZoneVmExtensionPolicyRequest'];

coerce 'UpdateZoneVmExtensionPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UpdateZoneVmExtensionPolicyRequest'->new($_) };

declare 'RepeatedUpdateZoneVmExtensionPolicyRequest',
    as ArrayRef[UpdateZoneVmExtensionPolicyRequest()];

coerce 'RepeatedUpdateZoneVmExtensionPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UpdateZoneVmExtensionPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringUpdateZoneVmExtensionPolicyRequest',
    as HashRef[UpdateZoneVmExtensionPolicyRequest()];

declare 'UrlMap',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMap'];

coerce 'UrlMap',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMap'->new($_) };

declare 'RepeatedUrlMap',
    as ArrayRef[UrlMap()];

coerce 'RepeatedUrlMap',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMap'->new($_) } @$_ ] };

declare 'MapStringUrlMap',
    as HashRef[UrlMap()];

declare 'UrlMapList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapList'];

coerce 'UrlMapList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapList'->new($_) };

declare 'RepeatedUrlMapList',
    as ArrayRef[UrlMapList()];

coerce 'RepeatedUrlMapList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapList'->new($_) } @$_ ] };

declare 'MapStringUrlMapList',
    as HashRef[UrlMapList()];

declare 'UrlMapReference',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapReference'];

coerce 'UrlMapReference',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapReference'->new($_) };

declare 'RepeatedUrlMapReference',
    as ArrayRef[UrlMapReference()];

coerce 'RepeatedUrlMapReference',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapReference'->new($_) } @$_ ] };

declare 'MapStringUrlMapReference',
    as HashRef[UrlMapReference()];

declare 'UrlMapTest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapTest'];

coerce 'UrlMapTest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapTest'->new($_) };

declare 'RepeatedUrlMapTest',
    as ArrayRef[UrlMapTest()];

coerce 'RepeatedUrlMapTest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapTest'->new($_) } @$_ ] };

declare 'MapStringUrlMapTest',
    as HashRef[UrlMapTest()];

declare 'UrlMapTestHeader',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapTestHeader'];

coerce 'UrlMapTestHeader',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapTestHeader'->new($_) };

declare 'RepeatedUrlMapTestHeader',
    as ArrayRef[UrlMapTestHeader()];

coerce 'RepeatedUrlMapTestHeader',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapTestHeader'->new($_) } @$_ ] };

declare 'MapStringUrlMapTestHeader',
    as HashRef[UrlMapTestHeader()];

declare 'UrlMapValidationResult',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapValidationResult'];

coerce 'UrlMapValidationResult',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapValidationResult'->new($_) };

declare 'RepeatedUrlMapValidationResult',
    as ArrayRef[UrlMapValidationResult()];

coerce 'RepeatedUrlMapValidationResult',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapValidationResult'->new($_) } @$_ ] };

declare 'MapStringUrlMapValidationResult',
    as HashRef[UrlMapValidationResult()];

declare 'UrlMapsAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapsAggregatedList'];

coerce 'UrlMapsAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapsAggregatedList'->new($_) };

declare 'RepeatedUrlMapsAggregatedList',
    as ArrayRef[UrlMapsAggregatedList()];

coerce 'RepeatedUrlMapsAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapsAggregatedList'->new($_) } @$_ ] };

declare 'MapStringUrlMapsAggregatedList',
    as HashRef[UrlMapsAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapsAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapsAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapsAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'UrlMapsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapsScopedList'];

coerce 'UrlMapsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapsScopedList'->new($_) };

declare 'RepeatedUrlMapsScopedList',
    as ArrayRef[UrlMapsScopedList()];

coerce 'RepeatedUrlMapsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapsScopedList'->new($_) } @$_ ] };

declare 'MapStringUrlMapsScopedList',
    as HashRef[UrlMapsScopedList()];

declare 'UrlMapsValidateRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapsValidateRequest'];

coerce 'UrlMapsValidateRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapsValidateRequest'->new($_) };

declare 'RepeatedUrlMapsValidateRequest',
    as ArrayRef[UrlMapsValidateRequest()];

coerce 'RepeatedUrlMapsValidateRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapsValidateRequest'->new($_) } @$_ ] };

declare 'MapStringUrlMapsValidateRequest',
    as HashRef[UrlMapsValidateRequest()];

declare 'LoadBalancingSchemes',
    as (Int | Str);

declare 'UrlMapsValidateResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlMapsValidateResponse'];

coerce 'UrlMapsValidateResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlMapsValidateResponse'->new($_) };

declare 'RepeatedUrlMapsValidateResponse',
    as ArrayRef[UrlMapsValidateResponse()];

coerce 'RepeatedUrlMapsValidateResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlMapsValidateResponse'->new($_) } @$_ ] };

declare 'MapStringUrlMapsValidateResponse',
    as HashRef[UrlMapsValidateResponse()];

declare 'UrlRewrite',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UrlRewrite'];

coerce 'UrlRewrite',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UrlRewrite'->new($_) };

declare 'RepeatedUrlRewrite',
    as ArrayRef[UrlRewrite()];

coerce 'RepeatedUrlRewrite',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UrlRewrite'->new($_) } @$_ ] };

declare 'MapStringUrlRewrite',
    as HashRef[UrlRewrite()];

declare 'UsableSubnetwork',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UsableSubnetwork'];

coerce 'UsableSubnetwork',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UsableSubnetwork'->new($_) };

declare 'RepeatedUsableSubnetwork',
    as ArrayRef[UsableSubnetwork()];

coerce 'RepeatedUsableSubnetwork',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UsableSubnetwork'->new($_) } @$_ ] };

declare 'MapStringUsableSubnetwork',
    as HashRef[UsableSubnetwork()];

declare 'Ipv6AccessType',
    as (Int | Str);

declare 'Purpose',
    as (Int | Str);

declare 'Role',
    as (Int | Str);

declare 'StackType',
    as (Int | Str);

declare 'UsableSubnetworkSecondaryRange',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UsableSubnetworkSecondaryRange'];

coerce 'UsableSubnetworkSecondaryRange',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UsableSubnetworkSecondaryRange'->new($_) };

declare 'RepeatedUsableSubnetworkSecondaryRange',
    as ArrayRef[UsableSubnetworkSecondaryRange()];

coerce 'RepeatedUsableSubnetworkSecondaryRange',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UsableSubnetworkSecondaryRange'->new($_) } @$_ ] };

declare 'MapStringUsableSubnetworkSecondaryRange',
    as HashRef[UsableSubnetworkSecondaryRange()];

declare 'UsableSubnetworksAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UsableSubnetworksAggregatedList'];

coerce 'UsableSubnetworksAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UsableSubnetworksAggregatedList'->new($_) };

declare 'RepeatedUsableSubnetworksAggregatedList',
    as ArrayRef[UsableSubnetworksAggregatedList()];

coerce 'RepeatedUsableSubnetworksAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UsableSubnetworksAggregatedList'->new($_) } @$_ ] };

declare 'MapStringUsableSubnetworksAggregatedList',
    as HashRef[UsableSubnetworksAggregatedList()];

declare 'UsageExportLocation',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::UsageExportLocation'];

coerce 'UsageExportLocation',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::UsageExportLocation'->new($_) };

declare 'RepeatedUsageExportLocation',
    as ArrayRef[UsageExportLocation()];

coerce 'RepeatedUsageExportLocation',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::UsageExportLocation'->new($_) } @$_ ] };

declare 'MapStringUsageExportLocation',
    as HashRef[UsageExportLocation()];

declare 'ValidateRegionUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ValidateRegionUrlMapRequest'];

coerce 'ValidateRegionUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ValidateRegionUrlMapRequest'->new($_) };

declare 'RepeatedValidateRegionUrlMapRequest',
    as ArrayRef[ValidateRegionUrlMapRequest()];

coerce 'RepeatedValidateRegionUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ValidateRegionUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringValidateRegionUrlMapRequest',
    as HashRef[ValidateRegionUrlMapRequest()];

declare 'ValidateUrlMapRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ValidateUrlMapRequest'];

coerce 'ValidateUrlMapRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ValidateUrlMapRequest'->new($_) };

declare 'RepeatedValidateUrlMapRequest',
    as ArrayRef[ValidateUrlMapRequest()];

coerce 'RepeatedValidateUrlMapRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ValidateUrlMapRequest'->new($_) } @$_ ] };

declare 'MapStringValidateUrlMapRequest',
    as HashRef[ValidateUrlMapRequest()];

declare 'VmEndpointNatMappings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmEndpointNatMappings'];

coerce 'VmEndpointNatMappings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappings'->new($_) };

declare 'RepeatedVmEndpointNatMappings',
    as ArrayRef[VmEndpointNatMappings()];

coerce 'RepeatedVmEndpointNatMappings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappings'->new($_) } @$_ ] };

declare 'MapStringVmEndpointNatMappings',
    as HashRef[VmEndpointNatMappings()];

declare 'VmEndpointNatMappingsInterfaceNatMappings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsInterfaceNatMappings'];

coerce 'VmEndpointNatMappingsInterfaceNatMappings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsInterfaceNatMappings'->new($_) };

declare 'RepeatedVmEndpointNatMappingsInterfaceNatMappings',
    as ArrayRef[VmEndpointNatMappingsInterfaceNatMappings()];

coerce 'RepeatedVmEndpointNatMappingsInterfaceNatMappings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsInterfaceNatMappings'->new($_) } @$_ ] };

declare 'MapStringVmEndpointNatMappingsInterfaceNatMappings',
    as HashRef[VmEndpointNatMappingsInterfaceNatMappings()];

declare 'VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings'];

coerce 'VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings'->new($_) };

declare 'RepeatedVmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings',
    as ArrayRef[VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings()];

coerce 'RepeatedVmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings'->new($_) } @$_ ] };

declare 'MapStringVmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings',
    as HashRef[VmEndpointNatMappingsInterfaceNatMappingsNatRuleMappings()];

declare 'VmEndpointNatMappingsList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsList'];

coerce 'VmEndpointNatMappingsList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsList'->new($_) };

declare 'RepeatedVmEndpointNatMappingsList',
    as ArrayRef[VmEndpointNatMappingsList()];

coerce 'RepeatedVmEndpointNatMappingsList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmEndpointNatMappingsList'->new($_) } @$_ ] };

declare 'MapStringVmEndpointNatMappingsList',
    as HashRef[VmEndpointNatMappingsList()];

declare 'VmExtensionPoliciesScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPoliciesScopedList'];

coerce 'VmExtensionPoliciesScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPoliciesScopedList'->new($_) };

declare 'RepeatedVmExtensionPoliciesScopedList',
    as ArrayRef[VmExtensionPoliciesScopedList()];

coerce 'RepeatedVmExtensionPoliciesScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPoliciesScopedList'->new($_) } @$_ ] };

declare 'MapStringVmExtensionPoliciesScopedList',
    as HashRef[VmExtensionPoliciesScopedList()];

declare 'VmExtensionPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicy'];

coerce 'VmExtensionPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicy'->new($_) };

declare 'RepeatedVmExtensionPolicy',
    as ArrayRef[VmExtensionPolicy()];

coerce 'RepeatedVmExtensionPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicy'->new($_) } @$_ ] };

declare 'MapStringVmExtensionPolicy',
    as HashRef[VmExtensionPolicy()];

declare 'State',
    as (Int | Str);

declare 'ExtensionPoliciesEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicy::ExtensionPoliciesEntry'];

coerce 'ExtensionPoliciesEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicy::ExtensionPoliciesEntry'->new($_) };

declare 'RepeatedExtensionPoliciesEntry',
    as ArrayRef[ExtensionPoliciesEntry()];

coerce 'RepeatedExtensionPoliciesEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicy::ExtensionPoliciesEntry'->new($_) } @$_ ] };

declare 'MapStringExtensionPoliciesEntry',
    as HashRef[ExtensionPoliciesEntry()];

declare 'VmExtensionPolicyAggregatedListResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicyAggregatedListResponse'];

coerce 'VmExtensionPolicyAggregatedListResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyAggregatedListResponse'->new($_) };

declare 'RepeatedVmExtensionPolicyAggregatedListResponse',
    as ArrayRef[VmExtensionPolicyAggregatedListResponse()];

coerce 'RepeatedVmExtensionPolicyAggregatedListResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyAggregatedListResponse'->new($_) } @$_ ] };

declare 'MapStringVmExtensionPolicyAggregatedListResponse',
    as HashRef[VmExtensionPolicyAggregatedListResponse()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicyAggregatedListResponse::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyAggregatedListResponse::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyAggregatedListResponse::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'VmExtensionPolicyExtensionPolicy',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicyExtensionPolicy'];

coerce 'VmExtensionPolicyExtensionPolicy',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyExtensionPolicy'->new($_) };

declare 'RepeatedVmExtensionPolicyExtensionPolicy',
    as ArrayRef[VmExtensionPolicyExtensionPolicy()];

coerce 'RepeatedVmExtensionPolicyExtensionPolicy',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyExtensionPolicy'->new($_) } @$_ ] };

declare 'MapStringVmExtensionPolicyExtensionPolicy',
    as HashRef[VmExtensionPolicyExtensionPolicy()];

declare 'VmExtensionPolicyInstanceSelector',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicyInstanceSelector'];

coerce 'VmExtensionPolicyInstanceSelector',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyInstanceSelector'->new($_) };

declare 'RepeatedVmExtensionPolicyInstanceSelector',
    as ArrayRef[VmExtensionPolicyInstanceSelector()];

coerce 'RepeatedVmExtensionPolicyInstanceSelector',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyInstanceSelector'->new($_) } @$_ ] };

declare 'MapStringVmExtensionPolicyInstanceSelector',
    as HashRef[VmExtensionPolicyInstanceSelector()];

declare 'VmExtensionPolicyLabelSelector',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicyLabelSelector'];

coerce 'VmExtensionPolicyLabelSelector',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyLabelSelector'->new($_) };

declare 'RepeatedVmExtensionPolicyLabelSelector',
    as ArrayRef[VmExtensionPolicyLabelSelector()];

coerce 'RepeatedVmExtensionPolicyLabelSelector',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyLabelSelector'->new($_) } @$_ ] };

declare 'MapStringVmExtensionPolicyLabelSelector',
    as HashRef[VmExtensionPolicyLabelSelector()];

declare 'InclusionLabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicyLabelSelector::InclusionLabelsEntry'];

coerce 'InclusionLabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyLabelSelector::InclusionLabelsEntry'->new($_) };

declare 'RepeatedInclusionLabelsEntry',
    as ArrayRef[InclusionLabelsEntry()];

coerce 'RepeatedInclusionLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyLabelSelector::InclusionLabelsEntry'->new($_) } @$_ ] };

declare 'MapStringInclusionLabelsEntry',
    as HashRef[InclusionLabelsEntry()];

declare 'VmExtensionPolicyList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VmExtensionPolicyList'];

coerce 'VmExtensionPolicyList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyList'->new($_) };

declare 'RepeatedVmExtensionPolicyList',
    as ArrayRef[VmExtensionPolicyList()];

coerce 'RepeatedVmExtensionPolicyList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VmExtensionPolicyList'->new($_) } @$_ ] };

declare 'MapStringVmExtensionPolicyList',
    as HashRef[VmExtensionPolicyList()];

declare 'VpnGateway',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGateway'];

coerce 'VpnGateway',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGateway'->new($_) };

declare 'RepeatedVpnGateway',
    as ArrayRef[VpnGateway()];

coerce 'RepeatedVpnGateway',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGateway'->new($_) } @$_ ] };

declare 'MapStringVpnGateway',
    as HashRef[VpnGateway()];

declare 'GatewayIpVersion',
    as (Int | Str);

declare 'StackType',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGateway::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGateway::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGateway::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'VpnGatewayAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayAggregatedList'];

coerce 'VpnGatewayAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayAggregatedList'->new($_) };

declare 'RepeatedVpnGatewayAggregatedList',
    as ArrayRef[VpnGatewayAggregatedList()];

coerce 'RepeatedVpnGatewayAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayAggregatedList'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayAggregatedList',
    as HashRef[VpnGatewayAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'VpnGatewayList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayList'];

coerce 'VpnGatewayList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayList'->new($_) };

declare 'RepeatedVpnGatewayList',
    as ArrayRef[VpnGatewayList()];

coerce 'RepeatedVpnGatewayList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayList'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayList',
    as HashRef[VpnGatewayList()];

declare 'VpnGatewayParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayParams'];

coerce 'VpnGatewayParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayParams'->new($_) };

declare 'RepeatedVpnGatewayParams',
    as ArrayRef[VpnGatewayParams()];

coerce 'RepeatedVpnGatewayParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayParams'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayParams',
    as HashRef[VpnGatewayParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'VpnGatewayStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayStatus'];

coerce 'VpnGatewayStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatus'->new($_) };

declare 'RepeatedVpnGatewayStatus',
    as ArrayRef[VpnGatewayStatus()];

coerce 'RepeatedVpnGatewayStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatus'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayStatus',
    as HashRef[VpnGatewayStatus()];

declare 'VpnGatewayStatusHighAvailabilityRequirementState',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayStatusHighAvailabilityRequirementState'];

coerce 'VpnGatewayStatusHighAvailabilityRequirementState',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatusHighAvailabilityRequirementState'->new($_) };

declare 'RepeatedVpnGatewayStatusHighAvailabilityRequirementState',
    as ArrayRef[VpnGatewayStatusHighAvailabilityRequirementState()];

coerce 'RepeatedVpnGatewayStatusHighAvailabilityRequirementState',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatusHighAvailabilityRequirementState'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayStatusHighAvailabilityRequirementState',
    as HashRef[VpnGatewayStatusHighAvailabilityRequirementState()];

declare 'State',
    as (Int | Str);

declare 'UnsatisfiedReason',
    as (Int | Str);

declare 'VpnGatewayStatusTunnel',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayStatusTunnel'];

coerce 'VpnGatewayStatusTunnel',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatusTunnel'->new($_) };

declare 'RepeatedVpnGatewayStatusTunnel',
    as ArrayRef[VpnGatewayStatusTunnel()];

coerce 'RepeatedVpnGatewayStatusTunnel',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatusTunnel'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayStatusTunnel',
    as HashRef[VpnGatewayStatusTunnel()];

declare 'VpnGatewayStatusVpnConnection',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayStatusVpnConnection'];

coerce 'VpnGatewayStatusVpnConnection',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatusVpnConnection'->new($_) };

declare 'RepeatedVpnGatewayStatusVpnConnection',
    as ArrayRef[VpnGatewayStatusVpnConnection()];

coerce 'RepeatedVpnGatewayStatusVpnConnection',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayStatusVpnConnection'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayStatusVpnConnection',
    as HashRef[VpnGatewayStatusVpnConnection()];

declare 'VpnGatewayVpnGatewayInterface',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewayVpnGatewayInterface'];

coerce 'VpnGatewayVpnGatewayInterface',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewayVpnGatewayInterface'->new($_) };

declare 'RepeatedVpnGatewayVpnGatewayInterface',
    as ArrayRef[VpnGatewayVpnGatewayInterface()];

coerce 'RepeatedVpnGatewayVpnGatewayInterface',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewayVpnGatewayInterface'->new($_) } @$_ ] };

declare 'MapStringVpnGatewayVpnGatewayInterface',
    as HashRef[VpnGatewayVpnGatewayInterface()];

declare 'VpnGatewaysGetStatusResponse',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewaysGetStatusResponse'];

coerce 'VpnGatewaysGetStatusResponse',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewaysGetStatusResponse'->new($_) };

declare 'RepeatedVpnGatewaysGetStatusResponse',
    as ArrayRef[VpnGatewaysGetStatusResponse()];

coerce 'RepeatedVpnGatewaysGetStatusResponse',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewaysGetStatusResponse'->new($_) } @$_ ] };

declare 'MapStringVpnGatewaysGetStatusResponse',
    as HashRef[VpnGatewaysGetStatusResponse()];

declare 'VpnGatewaysScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnGatewaysScopedList'];

coerce 'VpnGatewaysScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnGatewaysScopedList'->new($_) };

declare 'RepeatedVpnGatewaysScopedList',
    as ArrayRef[VpnGatewaysScopedList()];

coerce 'RepeatedVpnGatewaysScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnGatewaysScopedList'->new($_) } @$_ ] };

declare 'MapStringVpnGatewaysScopedList',
    as HashRef[VpnGatewaysScopedList()];

declare 'VpnTunnel',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnel'];

coerce 'VpnTunnel',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnel'->new($_) };

declare 'RepeatedVpnTunnel',
    as ArrayRef[VpnTunnel()];

coerce 'RepeatedVpnTunnel',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnel'->new($_) } @$_ ] };

declare 'MapStringVpnTunnel',
    as HashRef[VpnTunnel()];

declare 'Status',
    as (Int | Str);

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnel::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnel::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnel::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'VpnTunnelAggregatedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelAggregatedList'];

coerce 'VpnTunnelAggregatedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelAggregatedList'->new($_) };

declare 'RepeatedVpnTunnelAggregatedList',
    as ArrayRef[VpnTunnelAggregatedList()];

coerce 'RepeatedVpnTunnelAggregatedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelAggregatedList'->new($_) } @$_ ] };

declare 'MapStringVpnTunnelAggregatedList',
    as HashRef[VpnTunnelAggregatedList()];

declare 'ItemsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelAggregatedList::ItemsEntry'];

coerce 'ItemsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelAggregatedList::ItemsEntry'->new($_) };

declare 'RepeatedItemsEntry',
    as ArrayRef[ItemsEntry()];

coerce 'RepeatedItemsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelAggregatedList::ItemsEntry'->new($_) } @$_ ] };

declare 'MapStringItemsEntry',
    as HashRef[ItemsEntry()];

declare 'VpnTunnelCipherSuite',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelCipherSuite'];

coerce 'VpnTunnelCipherSuite',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelCipherSuite'->new($_) };

declare 'RepeatedVpnTunnelCipherSuite',
    as ArrayRef[VpnTunnelCipherSuite()];

coerce 'RepeatedVpnTunnelCipherSuite',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelCipherSuite'->new($_) } @$_ ] };

declare 'MapStringVpnTunnelCipherSuite',
    as HashRef[VpnTunnelCipherSuite()];

declare 'VpnTunnelList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelList'];

coerce 'VpnTunnelList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelList'->new($_) };

declare 'RepeatedVpnTunnelList',
    as ArrayRef[VpnTunnelList()];

coerce 'RepeatedVpnTunnelList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelList'->new($_) } @$_ ] };

declare 'MapStringVpnTunnelList',
    as HashRef[VpnTunnelList()];

declare 'VpnTunnelParams',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelParams'];

coerce 'VpnTunnelParams',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelParams'->new($_) };

declare 'RepeatedVpnTunnelParams',
    as ArrayRef[VpnTunnelParams()];

coerce 'RepeatedVpnTunnelParams',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelParams'->new($_) } @$_ ] };

declare 'MapStringVpnTunnelParams',
    as HashRef[VpnTunnelParams()];

declare 'ResourceManagerTagsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelParams::ResourceManagerTagsEntry'];

coerce 'ResourceManagerTagsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelParams::ResourceManagerTagsEntry'->new($_) };

declare 'RepeatedResourceManagerTagsEntry',
    as ArrayRef[ResourceManagerTagsEntry()];

coerce 'RepeatedResourceManagerTagsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelParams::ResourceManagerTagsEntry'->new($_) } @$_ ] };

declare 'MapStringResourceManagerTagsEntry',
    as HashRef[ResourceManagerTagsEntry()];

declare 'VpnTunnelPhase1Algorithms',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelPhase1Algorithms'];

coerce 'VpnTunnelPhase1Algorithms',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelPhase1Algorithms'->new($_) };

declare 'RepeatedVpnTunnelPhase1Algorithms',
    as ArrayRef[VpnTunnelPhase1Algorithms()];

coerce 'RepeatedVpnTunnelPhase1Algorithms',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelPhase1Algorithms'->new($_) } @$_ ] };

declare 'MapStringVpnTunnelPhase1Algorithms',
    as HashRef[VpnTunnelPhase1Algorithms()];

declare 'VpnTunnelPhase2Algorithms',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelPhase2Algorithms'];

coerce 'VpnTunnelPhase2Algorithms',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelPhase2Algorithms'->new($_) };

declare 'RepeatedVpnTunnelPhase2Algorithms',
    as ArrayRef[VpnTunnelPhase2Algorithms()];

coerce 'RepeatedVpnTunnelPhase2Algorithms',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelPhase2Algorithms'->new($_) } @$_ ] };

declare 'MapStringVpnTunnelPhase2Algorithms',
    as HashRef[VpnTunnelPhase2Algorithms()];

declare 'VpnTunnelsScopedList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::VpnTunnelsScopedList'];

coerce 'VpnTunnelsScopedList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::VpnTunnelsScopedList'->new($_) };

declare 'RepeatedVpnTunnelsScopedList',
    as ArrayRef[VpnTunnelsScopedList()];

coerce 'RepeatedVpnTunnelsScopedList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::VpnTunnelsScopedList'->new($_) } @$_ ] };

declare 'MapStringVpnTunnelsScopedList',
    as HashRef[VpnTunnelsScopedList()];

declare 'WafExpressionSet',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WafExpressionSet'];

coerce 'WafExpressionSet',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WafExpressionSet'->new($_) };

declare 'RepeatedWafExpressionSet',
    as ArrayRef[WafExpressionSet()];

coerce 'RepeatedWafExpressionSet',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WafExpressionSet'->new($_) } @$_ ] };

declare 'MapStringWafExpressionSet',
    as HashRef[WafExpressionSet()];

declare 'WafExpressionSetExpression',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WafExpressionSetExpression'];

coerce 'WafExpressionSetExpression',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WafExpressionSetExpression'->new($_) };

declare 'RepeatedWafExpressionSetExpression',
    as ArrayRef[WafExpressionSetExpression()];

coerce 'RepeatedWafExpressionSetExpression',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WafExpressionSetExpression'->new($_) } @$_ ] };

declare 'MapStringWafExpressionSetExpression',
    as HashRef[WafExpressionSetExpression()];

declare 'WaitGlobalOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WaitGlobalOperationRequest'];

coerce 'WaitGlobalOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WaitGlobalOperationRequest'->new($_) };

declare 'RepeatedWaitGlobalOperationRequest',
    as ArrayRef[WaitGlobalOperationRequest()];

coerce 'RepeatedWaitGlobalOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WaitGlobalOperationRequest'->new($_) } @$_ ] };

declare 'MapStringWaitGlobalOperationRequest',
    as HashRef[WaitGlobalOperationRequest()];

declare 'WaitRegionOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WaitRegionOperationRequest'];

coerce 'WaitRegionOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WaitRegionOperationRequest'->new($_) };

declare 'RepeatedWaitRegionOperationRequest',
    as ArrayRef[WaitRegionOperationRequest()];

coerce 'RepeatedWaitRegionOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WaitRegionOperationRequest'->new($_) } @$_ ] };

declare 'MapStringWaitRegionOperationRequest',
    as HashRef[WaitRegionOperationRequest()];

declare 'WaitZoneOperationRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WaitZoneOperationRequest'];

coerce 'WaitZoneOperationRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WaitZoneOperationRequest'->new($_) };

declare 'RepeatedWaitZoneOperationRequest',
    as ArrayRef[WaitZoneOperationRequest()];

coerce 'RepeatedWaitZoneOperationRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WaitZoneOperationRequest'->new($_) } @$_ ] };

declare 'MapStringWaitZoneOperationRequest',
    as HashRef[WaitZoneOperationRequest()];

declare 'Warning',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Warning'];

coerce 'Warning',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Warning'->new($_) };

declare 'RepeatedWarning',
    as ArrayRef[Warning()];

coerce 'RepeatedWarning',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Warning'->new($_) } @$_ ] };

declare 'MapStringWarning',
    as HashRef[Warning()];

declare 'Code',
    as (Int | Str);

declare 'Warnings',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Warnings'];

coerce 'Warnings',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Warnings'->new($_) };

declare 'RepeatedWarnings',
    as ArrayRef[Warnings()];

coerce 'RepeatedWarnings',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Warnings'->new($_) } @$_ ] };

declare 'MapStringWarnings',
    as HashRef[Warnings()];

declare 'Code',
    as (Int | Str);

declare 'WeightedBackendService',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WeightedBackendService'];

coerce 'WeightedBackendService',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WeightedBackendService'->new($_) };

declare 'RepeatedWeightedBackendService',
    as ArrayRef[WeightedBackendService()];

coerce 'RepeatedWeightedBackendService',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WeightedBackendService'->new($_) } @$_ ] };

declare 'MapStringWeightedBackendService',
    as HashRef[WeightedBackendService()];

declare 'Wire',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Wire'];

coerce 'Wire',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Wire'->new($_) };

declare 'RepeatedWire',
    as ArrayRef[Wire()];

coerce 'RepeatedWire',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Wire'->new($_) } @$_ ] };

declare 'MapStringWire',
    as HashRef[Wire()];

declare 'WireEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireEndpoint'];

coerce 'WireEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireEndpoint'->new($_) };

declare 'RepeatedWireEndpoint',
    as ArrayRef[WireEndpoint()];

coerce 'RepeatedWireEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireEndpoint'->new($_) } @$_ ] };

declare 'MapStringWireEndpoint',
    as HashRef[WireEndpoint()];

declare 'WireGroup',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroup'];

coerce 'WireGroup',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroup'->new($_) };

declare 'RepeatedWireGroup',
    as ArrayRef[WireGroup()];

coerce 'RepeatedWireGroup',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroup'->new($_) } @$_ ] };

declare 'MapStringWireGroup',
    as HashRef[WireGroup()];

declare 'EndpointsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroup::EndpointsEntry'];

coerce 'EndpointsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroup::EndpointsEntry'->new($_) };

declare 'RepeatedEndpointsEntry',
    as ArrayRef[EndpointsEntry()];

coerce 'RepeatedEndpointsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroup::EndpointsEntry'->new($_) } @$_ ] };

declare 'MapStringEndpointsEntry',
    as HashRef[EndpointsEntry()];

declare 'WireGroupEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroupEndpoint'];

coerce 'WireGroupEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroupEndpoint'->new($_) };

declare 'RepeatedWireGroupEndpoint',
    as ArrayRef[WireGroupEndpoint()];

coerce 'RepeatedWireGroupEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroupEndpoint'->new($_) } @$_ ] };

declare 'MapStringWireGroupEndpoint',
    as HashRef[WireGroupEndpoint()];

declare 'InterconnectsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroupEndpoint::InterconnectsEntry'];

coerce 'InterconnectsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroupEndpoint::InterconnectsEntry'->new($_) };

declare 'RepeatedInterconnectsEntry',
    as ArrayRef[InterconnectsEntry()];

coerce 'RepeatedInterconnectsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroupEndpoint::InterconnectsEntry'->new($_) } @$_ ] };

declare 'MapStringInterconnectsEntry',
    as HashRef[InterconnectsEntry()];

declare 'WireGroupEndpointInterconnect',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroupEndpointInterconnect'];

coerce 'WireGroupEndpointInterconnect',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroupEndpointInterconnect'->new($_) };

declare 'RepeatedWireGroupEndpointInterconnect',
    as ArrayRef[WireGroupEndpointInterconnect()];

coerce 'RepeatedWireGroupEndpointInterconnect',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroupEndpointInterconnect'->new($_) } @$_ ] };

declare 'MapStringWireGroupEndpointInterconnect',
    as HashRef[WireGroupEndpointInterconnect()];

declare 'WireGroupList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroupList'];

coerce 'WireGroupList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroupList'->new($_) };

declare 'RepeatedWireGroupList',
    as ArrayRef[WireGroupList()];

coerce 'RepeatedWireGroupList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroupList'->new($_) } @$_ ] };

declare 'MapStringWireGroupList',
    as HashRef[WireGroupList()];

declare 'WireGroupTopology',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroupTopology'];

coerce 'WireGroupTopology',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroupTopology'->new($_) };

declare 'RepeatedWireGroupTopology',
    as ArrayRef[WireGroupTopology()];

coerce 'RepeatedWireGroupTopology',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroupTopology'->new($_) } @$_ ] };

declare 'MapStringWireGroupTopology',
    as HashRef[WireGroupTopology()];

declare 'WireGroupTopologyEndpoint',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireGroupTopologyEndpoint'];

coerce 'WireGroupTopologyEndpoint',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireGroupTopologyEndpoint'->new($_) };

declare 'RepeatedWireGroupTopologyEndpoint',
    as ArrayRef[WireGroupTopologyEndpoint()];

coerce 'RepeatedWireGroupTopologyEndpoint',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireGroupTopologyEndpoint'->new($_) } @$_ ] };

declare 'MapStringWireGroupTopologyEndpoint',
    as HashRef[WireGroupTopologyEndpoint()];

declare 'WireProperties',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WireProperties'];

coerce 'WireProperties',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WireProperties'->new($_) };

declare 'RepeatedWireProperties',
    as ArrayRef[WireProperties()];

coerce 'RepeatedWireProperties',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WireProperties'->new($_) } @$_ ] };

declare 'MapStringWireProperties',
    as HashRef[WireProperties()];

declare 'BandwidthAllocation',
    as (Int | Str);

declare 'FaultResponse',
    as (Int | Str);

declare 'WithdrawPublicAdvertisedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WithdrawPublicAdvertisedPrefixeRequest'];

coerce 'WithdrawPublicAdvertisedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WithdrawPublicAdvertisedPrefixeRequest'->new($_) };

declare 'RepeatedWithdrawPublicAdvertisedPrefixeRequest',
    as ArrayRef[WithdrawPublicAdvertisedPrefixeRequest()];

coerce 'RepeatedWithdrawPublicAdvertisedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WithdrawPublicAdvertisedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringWithdrawPublicAdvertisedPrefixeRequest',
    as HashRef[WithdrawPublicAdvertisedPrefixeRequest()];

declare 'WithdrawPublicDelegatedPrefixeRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WithdrawPublicDelegatedPrefixeRequest'];

coerce 'WithdrawPublicDelegatedPrefixeRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WithdrawPublicDelegatedPrefixeRequest'->new($_) };

declare 'RepeatedWithdrawPublicDelegatedPrefixeRequest',
    as ArrayRef[WithdrawPublicDelegatedPrefixeRequest()];

coerce 'RepeatedWithdrawPublicDelegatedPrefixeRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WithdrawPublicDelegatedPrefixeRequest'->new($_) } @$_ ] };

declare 'MapStringWithdrawPublicDelegatedPrefixeRequest',
    as HashRef[WithdrawPublicDelegatedPrefixeRequest()];

declare 'WorkloadIdentityConfig',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::WorkloadIdentityConfig'];

coerce 'WorkloadIdentityConfig',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::WorkloadIdentityConfig'->new($_) };

declare 'RepeatedWorkloadIdentityConfig',
    as ArrayRef[WorkloadIdentityConfig()];

coerce 'RepeatedWorkloadIdentityConfig',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::WorkloadIdentityConfig'->new($_) } @$_ ] };

declare 'MapStringWorkloadIdentityConfig',
    as HashRef[WorkloadIdentityConfig()];

declare 'XpnHostList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::XpnHostList'];

coerce 'XpnHostList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::XpnHostList'->new($_) };

declare 'RepeatedXpnHostList',
    as ArrayRef[XpnHostList()];

coerce 'RepeatedXpnHostList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::XpnHostList'->new($_) } @$_ ] };

declare 'MapStringXpnHostList',
    as HashRef[XpnHostList()];

declare 'XpnResourceId',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::XpnResourceId'];

coerce 'XpnResourceId',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::XpnResourceId'->new($_) };

declare 'RepeatedXpnResourceId',
    as ArrayRef[XpnResourceId()];

coerce 'RepeatedXpnResourceId',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::XpnResourceId'->new($_) } @$_ ] };

declare 'MapStringXpnResourceId',
    as HashRef[XpnResourceId()];

declare 'Type',
    as (Int | Str);

declare 'Zone',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::Zone'];

coerce 'Zone',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::Zone'->new($_) };

declare 'RepeatedZone',
    as ArrayRef[Zone()];

coerce 'RepeatedZone',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::Zone'->new($_) } @$_ ] };

declare 'MapStringZone',
    as HashRef[Zone()];

declare 'Status',
    as (Int | Str);

declare 'ZoneList',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ZoneList'];

coerce 'ZoneList',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ZoneList'->new($_) };

declare 'RepeatedZoneList',
    as ArrayRef[ZoneList()];

coerce 'RepeatedZoneList',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ZoneList'->new($_) } @$_ ] };

declare 'MapStringZoneList',
    as HashRef[ZoneList()];

declare 'ZoneResourceStatus',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ZoneResourceStatus'];

coerce 'ZoneResourceStatus',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ZoneResourceStatus'->new($_) };

declare 'RepeatedZoneResourceStatus',
    as ArrayRef[ZoneResourceStatus()];

coerce 'RepeatedZoneResourceStatus',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ZoneResourceStatus'->new($_) } @$_ ] };

declare 'MapStringZoneResourceStatus',
    as HashRef[ZoneResourceStatus()];

declare 'ZoneSetLabelsRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ZoneSetLabelsRequest'];

coerce 'ZoneSetLabelsRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ZoneSetLabelsRequest'->new($_) };

declare 'RepeatedZoneSetLabelsRequest',
    as ArrayRef[ZoneSetLabelsRequest()];

coerce 'RepeatedZoneSetLabelsRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ZoneSetLabelsRequest'->new($_) } @$_ ] };

declare 'MapStringZoneSetLabelsRequest',
    as HashRef[ZoneSetLabelsRequest()];

declare 'LabelsEntry',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ZoneSetLabelsRequest::LabelsEntry'];

coerce 'LabelsEntry',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ZoneSetLabelsRequest::LabelsEntry'->new($_) };

declare 'RepeatedLabelsEntry',
    as ArrayRef[LabelsEntry()];

coerce 'RepeatedLabelsEntry',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ZoneSetLabelsRequest::LabelsEntry'->new($_) } @$_ ] };

declare 'MapStringLabelsEntry',
    as HashRef[LabelsEntry()];

declare 'ZoneSetNestedPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ZoneSetNestedPolicyRequest'];

coerce 'ZoneSetNestedPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ZoneSetNestedPolicyRequest'->new($_) };

declare 'RepeatedZoneSetNestedPolicyRequest',
    as ArrayRef[ZoneSetNestedPolicyRequest()];

coerce 'RepeatedZoneSetNestedPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ZoneSetNestedPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringZoneSetNestedPolicyRequest',
    as HashRef[ZoneSetNestedPolicyRequest()];

declare 'ZoneSetPolicyRequest',
    as InstanceOf['Google::Cloud::Compute::V1::Compute::ZoneSetPolicyRequest'];

coerce 'ZoneSetPolicyRequest',
    from HashRef, via { 'Google::Cloud::Compute::V1::Compute::ZoneSetPolicyRequest'->new($_) };

declare 'RepeatedZoneSetPolicyRequest',
    as ArrayRef[ZoneSetPolicyRequest()];

coerce 'RepeatedZoneSetPolicyRequest',
    from ArrayRef[HashRef], via { [ map { 'Google::Cloud::Compute::V1::Compute::ZoneSetPolicyRequest'->new($_) } @$_ ] };

declare 'MapStringZoneSetPolicyRequest',
    as HashRef[ZoneSetPolicyRequest()];

1;

__END__

=head1 NAME

Google::Cloud::Compute::V1::Compute::Types - Type definitions and coercions

=head1 DESCRIPTION

Auto-generated Type::Tiny definitions and coercions for Protocol Buffers.

=head1 LICENSE AND COPYRIGHT

Copyright (C) 2026 Google LLC

This program is released under the Apache 2.0 license.

=cut
