Skip to main content

winterbaume_ec2/
views.rs

1//! Serde-compatible view types for EC2 state snapshots.
2
3use std::collections::HashMap;
4
5use serde::{Deserialize, Serialize};
6use winterbaume_core::{StateChangeNotifier, StateViewError, StatefulService};
7
8use crate::handlers::Ec2Service;
9use crate::state::Ec2State;
10use crate::types::{
11    AccessScopePathSpec, AddressTransfer, AsnAssociation, BillingOwnershipOffer, ByoipCidr,
12    CapacityBlock, CapacityBlockExtension, CapacityManagerDataExport,
13    CapacityManagerOrganizationsAccess, CapacityReservation, CapacityReservationCommitmentInfo,
14    CapacityReservationFleet, CapacityReservationFleetInstanceSpec,
15    CapacityReservationSpecificationResponse, CarrierGateway, ClientVpnAssociationStatus,
16    ClientVpnAuthorizationRule, ClientVpnAuthorizationRuleStatus, ClientVpnConnection,
17    ClientVpnConnectionStatus, ClientVpnEndpoint, ClientVpnEndpointStatus, ClientVpnRoute,
18    ClientVpnRouteStatus, ClientVpnTargetNetworkAssociation, CoipCidr, CoipPool, ConversionTask,
19    CustomerGateway, DeclarativePoliciesReport, DedicatedHost, DhcpConfiguration, DhcpOptions,
20    Ec2Fleet, EgressOnlyInternetGateway, ElasticIp, EnclaveCertificateIamRoleAssociation,
21    EoigwAttachment, ExportTask, FlowLog, IamInstanceProfileAssociation, IcmpTypeCode,
22    IgwAttachment, Image, ImportInstanceVolumeDetail, Instance, InstanceConnectEndpoint,
23    InstanceState, InternetGateway, InterruptibleCapacityReservationAllocation, IpPermission,
24    IpRange, Ipam, IpamByoasn, IpamExternalResourceVerificationToken, IpamOperatingRegion,
25    IpamPolicy, IpamPolicyAllocationRule, IpamPool, IpamPoolAllocation, IpamPoolCidr,
26    IpamPrefixListResolver, IpamPrefixListResolverTarget, IpamResourceDiscovery,
27    IpamResourceDiscoveryAssociation, IpamScope, Ipv6Range, KeyPair, LaunchTemplate,
28    LaunchTemplateVersion, LocalGateway, LocalGatewayRoute, LocalGatewayRouteTable,
29    LocalGatewayRouteTableVirtualInterfaceGroupAssociation, LocalGatewayRouteTableVpcAssociation,
30    LocalGatewayVirtualInterface, LocalGatewayVirtualInterfaceGroup, MacSipModificationTask,
31    MacVolumeOwnershipTask, ManagedPrefixList, MulticastSubnetAssociation, NatGateway,
32    NatGatewayAddressAssociation, NetworkAcl, NetworkAclAssociation, NetworkAclEntry,
33    NetworkInsightsAccessScope, NetworkInsightsAccessScopeAnalysis, NetworkInsightsAnalysis,
34    NetworkInsightsPath, NetworkInsightsPathFilter, NetworkInsightsPathFilterPortRange,
35    NetworkInterface, NetworkInterfacePermission, PacketHeaderStatementSpec, PathStatementSpec,
36    PlacementGroup, PortRange, PublicIpv4Pool, PublicIpv4PoolRange, ReplaceRootVolumeTask,
37    ResourceStatementSpec, Route, RouteServer, RouteServerAssociation, RouteServerBgpOptions,
38    RouteServerEndpoint, RouteServerPeer, RouteServerPeerOptions, RouteTable,
39    RouteTableAssociation, S3DestinationOptions, SecondaryNetwork, SecondarySubnet, SecurityGroup,
40    SecurityGroupVpcAssociation, Snapshot, SnapshotImportTask, SpotFleetRequest,
41    SpotInstanceRequest, Subnet, SubnetCidrReservationEntry, SubnetIpv6CidrAssoc,
42    TrafficMirrorFilter, TrafficMirrorFilterRule, TrafficMirrorPortRange, TrafficMirrorSession,
43    TrafficMirrorTarget, TransitGateway, TransitGatewayAttachmentBgpConfiguration,
44    TransitGatewayConnect, TransitGatewayConnectPeer, TransitGatewayMeteringPolicy,
45    TransitGatewayMeteringPolicyEntry, TransitGatewayMulticastDomain,
46    TransitGatewayMulticastDomainAssociation, TransitGatewayMulticastGroupMember,
47    TransitGatewayMulticastGroupSource, TransitGatewayPeeringAttachment, TransitGatewayPolicyTable,
48    TransitGatewayPolicyTableAssociation, TransitGatewayPrefixListReference, TransitGatewayRoute,
49    TransitGatewayRouteTable, TransitGatewayRouteTableAnnouncement, TransitGatewayVpcAttachment,
50    TrunkInterfaceAssociation, TypesPrefixListEntry, UserIdGroupPair, VerifiedAccessDeviceOptions,
51    VerifiedAccessEndpoint, VerifiedAccessEndpointCidrOptions, VerifiedAccessEndpointEniOptions,
52    VerifiedAccessEndpointLoadBalancerOptions, VerifiedAccessEndpointPortRange,
53    VerifiedAccessEndpointRdsOptions, VerifiedAccessGroup, VerifiedAccessInstance,
54    VerifiedAccessLogs, VerifiedAccessNativeApplicationOidcOptions, VerifiedAccessOidcOptions,
55    VerifiedAccessSseSpecification, VerifiedAccessTrustProvider,
56    VerifiedAccessTrustProviderAttachment, VgwVpcAttachment, Volume, VolumeAttachment, Vpc,
57    VpcBlockPublicAccessExclusion, VpcBlockPublicAccessOptions, VpcEncryptionControl, VpcEndpoint,
58    VpcEndpointConnection, VpcEndpointConnectionNotification, VpcEndpointServiceConfiguration,
59    VpcPeeringConnection, VpnConcentrator, VpnConnection, VpnConnectionOptions, VpnGateway,
60    VpnStaticRoute, VpnTunnelOptions,
61};
62
63/// Serializable view of the entire EC2 state for one account/region.
64#[derive(Debug, Clone, Default, Serialize, Deserialize)]
65pub struct Ec2StateView {
66    #[serde(default)]
67    pub vpcs: HashMap<String, VpcView>,
68    #[serde(default)]
69    pub subnets: HashMap<String, SubnetView>,
70    #[serde(default)]
71    pub igws: HashMap<String, InternetGatewayView>,
72    #[serde(default)]
73    pub security_groups: HashMap<String, SecurityGroupView>,
74    #[serde(default)]
75    pub route_tables: HashMap<String, RouteTableView>,
76    #[serde(default)]
77    pub key_pairs: HashMap<String, KeyPairView>,
78    #[serde(default)]
79    pub network_acls: HashMap<String, NetworkAclView>,
80    #[serde(default)]
81    pub elastic_ips: HashMap<String, ElasticIpView>,
82    #[serde(default)]
83    pub nat_gateways: HashMap<String, NatGatewayView>,
84    #[serde(default)]
85    pub dhcp_options: HashMap<String, DhcpOptionsView>,
86    #[serde(default)]
87    pub egress_only_igws: HashMap<String, EgressOnlyIgwView>,
88    #[serde(default)]
89    pub flow_logs: HashMap<String, FlowLogView>,
90    #[serde(default)]
91    pub vpc_peering_connections: HashMap<String, VpcPeeringConnectionView>,
92    #[serde(default)]
93    pub vpc_endpoints: HashMap<String, VpcEndpointView>,
94    #[serde(default)]
95    pub managed_prefix_lists: HashMap<String, ManagedPrefixListView>,
96    #[serde(default)]
97    pub customer_gateways: HashMap<String, CustomerGatewayView>,
98    #[serde(default)]
99    pub vpn_gateways: HashMap<String, VpnGatewayView>,
100    #[serde(default)]
101    pub vpn_connections: HashMap<String, VpnConnectionView>,
102    #[serde(default)]
103    pub carrier_gateways: HashMap<String, CarrierGatewayView>,
104    #[serde(default)]
105    pub network_interfaces: HashMap<String, NetworkInterfaceView>,
106    #[serde(default)]
107    pub vpc_cidr_associations: HashMap<String, String>,
108    #[serde(default)]
109    pub ebs_encryption_by_default: bool,
110    #[serde(default)]
111    pub transit_gateways: HashMap<String, TransitGatewayView>,
112    #[serde(default)]
113    pub tgw_vpc_attachments: HashMap<String, TgwVpcAttachmentView>,
114    #[serde(default)]
115    pub tgw_peering_attachments: HashMap<String, TgwPeeringAttachmentView>,
116    #[serde(default)]
117    pub tgw_route_tables: HashMap<String, TgwRouteTableView>,
118    #[serde(default)]
119    pub tgw_routes: HashMap<String, Vec<TgwRouteView>>,
120    #[serde(default)]
121    pub instances: HashMap<String, InstanceView>,
122    #[serde(default)]
123    pub volumes: HashMap<String, VolumeView>,
124    #[serde(default)]
125    pub snapshots: HashMap<String, SnapshotView>,
126    #[serde(default)]
127    pub images: HashMap<String, ImageView>,
128    #[serde(default)]
129    pub launch_templates: HashMap<String, LaunchTemplateView>,
130    #[serde(default)]
131    pub launch_template_versions: HashMap<String, Vec<LaunchTemplateVersionView>>,
132    #[serde(default)]
133    pub spot_requests: HashMap<String, SpotInstanceRequestView>,
134    #[serde(default)]
135    pub spot_datafeed_subscription: Option<SpotDatafeedSubscriptionView>,
136    #[serde(default)]
137    pub iam_instance_profile_associations: HashMap<String, IamInstanceProfileAssociationView>,
138    #[serde(default)]
139    pub dedicated_hosts: HashMap<String, DedicatedHostView>,
140    #[serde(default)]
141    pub ec2_fleets: HashMap<String, Ec2FleetView>,
142    #[serde(default)]
143    pub vpc_endpoint_service_configs: HashMap<String, VpcEndpointServiceConfigView>,
144    #[serde(default)]
145    pub spot_fleet_requests: HashMap<String, SpotFleetRequestView>,
146    #[serde(default)]
147    pub subnet_cidr_reservations: HashMap<String, SubnetCidrReservationView>,
148    #[serde(default)]
149    pub placement_groups: HashMap<String, PlacementGroupView>,
150    #[serde(default)]
151    pub network_interface_permissions: HashMap<String, NetworkInterfacePermissionView>,
152    #[serde(default)]
153    pub instance_connect_endpoints: HashMap<String, InstanceConnectEndpointView>,
154    #[serde(default)]
155    pub capacity_reservations: HashMap<String, CapacityReservationView>,
156    #[serde(default)]
157    pub capacity_reservation_fleets: HashMap<String, CapacityReservationFleetView>,
158    #[serde(default)]
159    pub coip_pools: HashMap<String, CoipPoolView>,
160    #[serde(default)]
161    pub byoip_cidrs: HashMap<String, ByoipCidrView>,
162    #[serde(default)]
163    pub public_ipv4_pools: HashMap<String, PublicIpv4PoolView>,
164    #[serde(default)]
165    pub coip_cidrs: Vec<CoipCidrView>,
166    #[serde(default)]
167    pub address_transfers: HashMap<String, AddressTransferView>,
168    #[serde(default)]
169    pub security_group_vpc_associations: Vec<SecurityGroupVpcAssociationView>,
170    #[serde(default)]
171    pub enclave_certificate_iam_role_associations: Vec<EnclaveCertificateIamRoleAssociationView>,
172    #[serde(default)]
173    pub mac_sip_modification_tasks: HashMap<String, MacSipModificationTaskView>,
174    #[serde(default)]
175    pub declarative_policies_reports: HashMap<String, DeclarativePoliciesReportView>,
176    #[serde(default)]
177    pub vpn_concentrators: HashMap<String, VpnConcentratorView>,
178    #[serde(default)]
179    pub vpc_endpoint_connections: Vec<VpcEndpointConnectionView>,
180    #[serde(default)]
181    pub vpc_endpoint_connection_notifications:
182        HashMap<String, VpcEndpointConnectionNotificationView>,
183    #[serde(default)]
184    pub vpc_block_public_access_exclusions: HashMap<String, VpcBlockPublicAccessExclusionView>,
185    #[serde(default)]
186    pub vpc_block_public_access_options: Option<VpcBlockPublicAccessOptionsView>,
187    #[serde(default)]
188    pub vpc_encryption_controls: HashMap<String, VpcEncryptionControlView>,
189    #[serde(default)]
190    pub mac_volume_ownership_tasks: HashMap<String, MacVolumeOwnershipTaskView>,
191    #[serde(default)]
192    pub replace_root_volume_tasks: HashMap<String, ReplaceRootVolumeTaskView>,
193    #[serde(default)]
194    pub snapshot_import_tasks: HashMap<String, SnapshotImportTaskView>,
195    #[serde(default)]
196    pub conversion_tasks: HashMap<String, ConversionTaskView>,
197    #[serde(default)]
198    pub export_tasks: HashMap<String, ExportTaskView>,
199    #[serde(default)]
200    pub import_tasks: HashMap<String, (String, Option<String>)>,
201    #[serde(default)]
202    pub trunk_interface_associations: HashMap<String, TrunkInterfaceAssociationView>,
203    #[serde(default)]
204    pub secondary_networks: HashMap<String, SecondaryNetworkView>,
205    #[serde(default)]
206    pub secondary_subnets: HashMap<String, SecondarySubnetView>,
207    #[serde(default)]
208    pub deleted_volumes_recycle_bin: HashMap<String, VolumeView>,
209    #[serde(default)]
210    pub deleted_snapshots_recycle_bin: HashMap<String, SnapshotView>,
211    // --- Group 5 additions ---
212    #[serde(default)]
213    pub reserved_instances_exchanges: HashMap<String, ReservedInstancesExchangeView>,
214    #[serde(default)]
215    pub reserved_instances_listings: HashMap<String, ReservedInstancesListingView>,
216    #[serde(default)]
217    pub queued_reserved_instances_purchases: HashMap<String, ReservedInstancesPurchaseView>,
218    #[serde(default)]
219    pub reserved_instances_modifications: HashMap<String, ReservedInstancesModificationView>,
220    #[serde(default)]
221    pub reserved_instances_purchases: HashMap<String, ReservedInstancesPurchaseView>,
222    #[serde(default)]
223    pub reserved_instances: HashMap<String, ReservedInstancesRecordView>,
224    #[serde(default)]
225    pub fpga_images: HashMap<String, FpgaImageView>,
226    #[serde(default)]
227    pub image_usage_reports: HashMap<String, ImageUsageReportView>,
228    #[serde(default)]
229    pub restore_image_tasks: HashMap<String, RestoreImageTaskView>,
230    #[serde(default)]
231    pub store_image_tasks: HashMap<String, StoreImageTaskView>,
232    #[serde(default)]
233    pub import_image_tasks: HashMap<String, ImportImageTaskView>,
234    #[serde(default)]
235    pub allowed_image_criteria: Vec<AllowedImageCriterionView>,
236    #[serde(default)]
237    pub default_credit_specifications: HashMap<String, String>,
238    #[serde(default)]
239    pub instance_metadata_defaults: Option<InstanceMetadataDefaultsView>,
240    #[serde(default)]
241    pub instance_event_windows: HashMap<String, InstanceEventWindowView>,
242    #[serde(default)]
243    pub instance_event_notification_attributes: Option<InstanceTagNotificationAttributesView>,
244    #[serde(default)]
245    pub instance_events: HashMap<String, InstanceEventView>,
246    #[serde(default)]
247    pub host_reservations: HashMap<String, HostReservationView>,
248    #[serde(default)]
249    pub scheduled_instances: HashMap<String, ScheduledInstanceView>,
250    #[serde(default)]
251    pub az_group_opt_in: HashMap<String, String>,
252    #[serde(default)]
253    pub instance_status_reports: Vec<InstanceStatusReportView>,
254    // --- Group 6 additions ---
255    #[serde(default)]
256    pub network_insights_access_scopes: HashMap<String, NetworkInsightsAccessScopeView>,
257    #[serde(default)]
258    pub network_insights_access_scope_analyses:
259        HashMap<String, NetworkInsightsAccessScopeAnalysisView>,
260    #[serde(default)]
261    pub network_insights_paths: HashMap<String, NetworkInsightsPathView>,
262    #[serde(default)]
263    pub network_insights_analyses: HashMap<String, NetworkInsightsAnalysisView>,
264    #[serde(default)]
265    pub traffic_mirror_filters: HashMap<String, TrafficMirrorFilterView>,
266    #[serde(default)]
267    pub traffic_mirror_sessions: HashMap<String, TrafficMirrorSessionView>,
268    #[serde(default)]
269    pub traffic_mirror_targets: HashMap<String, TrafficMirrorTargetView>,
270    // --- Group 7 additions ---
271    #[serde(default)]
272    pub client_vpn_endpoints: HashMap<String, ClientVpnEndpointView>,
273    #[serde(default)]
274    pub client_vpn_target_network_associations:
275        HashMap<String, ClientVpnTargetNetworkAssociationView>,
276    #[serde(default)]
277    pub client_vpn_authorization_rules: Vec<ClientVpnAuthorizationRuleView>,
278    #[serde(default)]
279    pub client_vpn_routes: Vec<ClientVpnRouteView>,
280    #[serde(default)]
281    pub client_vpn_connections: HashMap<String, ClientVpnConnectionView>,
282    #[serde(default)]
283    pub local_gateways: HashMap<String, LocalGatewayView>,
284    #[serde(default)]
285    pub local_gateway_route_tables: HashMap<String, LocalGatewayRouteTableView>,
286    #[serde(default)]
287    pub local_gateway_routes: Vec<LocalGatewayRouteView>,
288    #[serde(default)]
289    pub local_gateway_route_table_virtual_interface_group_associations:
290        HashMap<String, LocalGatewayRouteTableVirtualInterfaceGroupAssociationView>,
291    #[serde(default)]
292    pub local_gateway_route_table_vpc_associations:
293        HashMap<String, LocalGatewayRouteTableVpcAssociationView>,
294    #[serde(default)]
295    pub local_gateway_virtual_interfaces: HashMap<String, LocalGatewayVirtualInterfaceView>,
296    #[serde(default)]
297    pub local_gateway_virtual_interface_groups:
298        HashMap<String, LocalGatewayVirtualInterfaceGroupView>,
299    // --- Group 8 additions ---
300    #[serde(default)]
301    pub route_servers: HashMap<String, RouteServerView>,
302    #[serde(default)]
303    pub route_server_endpoints: HashMap<String, RouteServerEndpointView>,
304    #[serde(default)]
305    pub route_server_peers: HashMap<String, RouteServerPeerView>,
306    #[serde(default)]
307    pub route_server_associations: Vec<RouteServerAssociationView>,
308    // --- Group 9 additions ---
309    #[serde(default)]
310    pub verified_access_instances: HashMap<String, VerifiedAccessInstanceView>,
311    #[serde(default)]
312    pub verified_access_trust_providers: HashMap<String, VerifiedAccessTrustProviderView>,
313    #[serde(default)]
314    pub verified_access_groups: HashMap<String, VerifiedAccessGroupView>,
315    #[serde(default)]
316    pub verified_access_endpoints: HashMap<String, VerifiedAccessEndpointView>,
317    #[serde(default)]
318    pub verified_access_trust_provider_attachments: Vec<VerifiedAccessTrustProviderAttachmentView>,
319    #[serde(default)]
320    pub verified_access_instance_logging_configurations: HashMap<String, VerifiedAccessLogsView>,
321    // --- Group 10 additions ---
322    #[serde(default)]
323    pub billing_ownership_offers: Vec<BillingOwnershipOfferView>,
324    #[serde(default)]
325    pub capacity_manager_data_exports: HashMap<String, CapacityManagerDataExportView>,
326    #[serde(default)]
327    pub interruptible_capacity_reservation_allocations:
328        HashMap<String, InterruptibleCapacityReservationAllocationView>,
329    #[serde(default)]
330    pub capacity_blocks: HashMap<String, CapacityBlockView>,
331    #[serde(default)]
332    pub capacity_block_extensions: HashMap<String, CapacityBlockExtensionView>,
333    #[serde(default)]
334    pub capacity_manager_organizations_access: Option<CapacityManagerOrganizationsAccessView>,
335    // --- Group 11 additions ---
336    #[serde(default)]
337    pub tgw_multicast_domains: HashMap<String, TransitGatewayMulticastDomainView>,
338    #[serde(default)]
339    pub tgw_multicast_domain_associations: Vec<TransitGatewayMulticastDomainAssociationView>,
340    #[serde(default)]
341    pub tgw_multicast_group_members: Vec<TransitGatewayMulticastGroupMemberView>,
342    #[serde(default)]
343    pub tgw_multicast_group_sources: Vec<TransitGatewayMulticastGroupSourceView>,
344    #[serde(default)]
345    pub tgw_connects: HashMap<String, TransitGatewayConnectView>,
346    #[serde(default)]
347    pub tgw_connect_peers: HashMap<String, TransitGatewayConnectPeerView>,
348    #[serde(default)]
349    pub tgw_metering_policies: HashMap<String, TransitGatewayMeteringPolicyView>,
350    #[serde(default)]
351    pub tgw_metering_policy_entries: Vec<TransitGatewayMeteringPolicyEntryView>,
352    #[serde(default)]
353    pub tgw_policy_tables: HashMap<String, TransitGatewayPolicyTableView>,
354    #[serde(default)]
355    pub tgw_policy_table_associations: Vec<TransitGatewayPolicyTableAssociationView>,
356    #[serde(default)]
357    pub tgw_prefix_list_references: Vec<TransitGatewayPrefixListReferenceView>,
358    #[serde(default)]
359    pub tgw_route_table_announcements: HashMap<String, TransitGatewayRouteTableAnnouncementView>,
360    // --- Group 12 additions ---
361    #[serde(default)]
362    pub ipams: HashMap<String, IpamView>,
363    #[serde(default)]
364    pub ipam_scopes: HashMap<String, IpamScopeView>,
365    #[serde(default)]
366    pub ipam_pools: HashMap<String, IpamPoolView>,
367    #[serde(default)]
368    pub ipam_pool_cidrs: Vec<IpamPoolCidrView>,
369    #[serde(default)]
370    pub ipam_pool_allocations: Vec<IpamPoolAllocationView>,
371    #[serde(default)]
372    pub ipam_resource_discoveries: HashMap<String, IpamResourceDiscoveryView>,
373    #[serde(default)]
374    pub ipam_resource_discovery_associations: HashMap<String, IpamResourceDiscoveryAssociationView>,
375    #[serde(default)]
376    pub ipam_byoasns: Vec<IpamByoasnView>,
377    #[serde(default)]
378    pub ipam_external_resource_verification_tokens:
379        HashMap<String, IpamExternalResourceVerificationTokenView>,
380    #[serde(default)]
381    pub ipam_policies: HashMap<String, IpamPolicyView>,
382    #[serde(default)]
383    pub ipam_prefix_list_resolvers: HashMap<String, IpamPrefixListResolverView>,
384    #[serde(default)]
385    pub ipam_prefix_list_resolver_targets: Vec<IpamPrefixListResolverTargetView>,
386    // --- Batch B additions ---
387    #[serde(default)]
388    pub volume_modifications: HashMap<String, VolumeModificationView>,
389    #[serde(default)]
390    pub import_volume_tasks: HashMap<String, ImportVolumeTaskView>,
391    #[serde(default)]
392    pub bundle_tasks: HashMap<String, BundleTaskView>,
393    #[serde(default)]
394    pub id_format: HashMap<String, IdFormatEntryView>,
395    #[serde(default)]
396    pub outpost_lags: HashMap<String, OutpostLagView>,
397    #[serde(default)]
398    pub export_image_tasks: HashMap<String, ExportImageTaskView>,
399    // --- Wave 4 additions ---
400    #[serde(default)]
401    pub ebs_default_kms_key_id: Option<String>,
402    #[serde(default)]
403    pub serial_console_access_enabled: bool,
404    #[serde(default)]
405    pub allowed_images_settings_state: Option<String>,
406    #[serde(default)]
407    pub image_block_public_access_state: Option<String>,
408    #[serde(default)]
409    pub aws_network_performance_subscriptions: Vec<AwsNetworkPerformanceSubscriptionView>,
410    #[serde(default)]
411    pub counters: CountersView,
412}
413
414#[derive(Debug, Clone, Default, Serialize, Deserialize)]
415pub struct AwsNetworkPerformanceSubscriptionView {
416    pub source: String,
417    pub destination: String,
418    pub metric: String,
419    pub statistic: String,
420    pub period: String,
421}
422
423// ---------------------------------------------------------------------------
424// Existing view structs (unchanged)
425// ---------------------------------------------------------------------------
426
427#[derive(Debug, Clone, Serialize, Deserialize)]
428pub struct VpcView {
429    pub vpc_id: String,
430    pub cidr_block: String,
431    pub state: String,
432    pub dhcp_options_id: String,
433    pub instance_tenancy: String,
434    pub is_default: bool,
435    pub enable_dns_hostnames: bool,
436    pub enable_dns_support: bool,
437    pub secondary_cidr_blocks: Vec<(String, String)>,
438    pub tags: HashMap<String, String>,
439    #[serde(default)]
440    pub classic_link_enabled: bool,
441}
442
443#[derive(Debug, Clone, Serialize, Deserialize)]
444pub struct SubnetView {
445    pub subnet_id: String,
446    pub vpc_id: String,
447    pub cidr_block: String,
448    pub availability_zone: String,
449    pub state: String,
450    pub available_ip_address_count: i64,
451    pub map_public_ip_on_launch: bool,
452    pub ipv6_cidr_blocks: Vec<SubnetIpv6CidrAssocView>,
453    pub tags: HashMap<String, String>,
454}
455
456#[derive(Debug, Clone, Serialize, Deserialize)]
457pub struct SubnetIpv6CidrAssocView {
458    pub association_id: String,
459    pub ipv6_cidr_block: String,
460    pub state: String,
461}
462
463#[derive(Debug, Clone, Serialize, Deserialize)]
464pub struct InternetGatewayView {
465    pub igw_id: String,
466    pub attachments: Vec<IgwAttachmentView>,
467    pub tags: HashMap<String, String>,
468}
469
470#[derive(Debug, Clone, Serialize, Deserialize)]
471pub struct IgwAttachmentView {
472    pub vpc_id: String,
473    pub state: String,
474}
475
476#[derive(Debug, Clone, Serialize, Deserialize)]
477pub struct SecurityGroupView {
478    pub group_id: String,
479    pub group_name: String,
480    pub description: String,
481    pub vpc_id: String,
482    pub owner_id: String,
483    pub ingress_rules: Vec<IpPermissionView>,
484    pub egress_rules: Vec<IpPermissionView>,
485    pub tags: HashMap<String, String>,
486}
487
488#[derive(Debug, Clone, Serialize, Deserialize)]
489pub struct IpPermissionView {
490    pub from_port: Option<i64>,
491    pub to_port: Option<i64>,
492    pub ip_protocol: String,
493    pub ip_ranges: Vec<IpRangeView>,
494    pub ipv6_ranges: Vec<Ipv6RangeView>,
495    pub user_id_group_pairs: Vec<UserIdGroupPairView>,
496}
497
498#[derive(Debug, Clone, Serialize, Deserialize)]
499pub struct IpRangeView {
500    pub cidr_ip: String,
501    pub description: Option<String>,
502}
503
504#[derive(Debug, Clone, Serialize, Deserialize)]
505pub struct Ipv6RangeView {
506    pub cidr_ipv6: String,
507    pub description: Option<String>,
508}
509
510#[derive(Debug, Clone, Serialize, Deserialize)]
511pub struct UserIdGroupPairView {
512    pub group_id: String,
513    pub user_id: Option<String>,
514}
515
516#[derive(Debug, Clone, Serialize, Deserialize)]
517pub struct RouteTableView {
518    pub route_table_id: String,
519    pub vpc_id: String,
520    pub routes: Vec<RouteView>,
521    pub associations: Vec<RouteTableAssociationView>,
522    #[serde(default)]
523    pub propagating_vgws: Vec<String>,
524    pub tags: HashMap<String, String>,
525}
526
527#[derive(Debug, Clone, Serialize, Deserialize)]
528pub struct RouteView {
529    pub destination_cidr_block: Option<String>,
530    pub destination_ipv6_cidr_block: Option<String>,
531    pub gateway_id: Option<String>,
532    pub state: String,
533    pub origin: String,
534}
535
536#[derive(Debug, Clone, Serialize, Deserialize)]
537pub struct RouteTableAssociationView {
538    pub association_id: String,
539    pub subnet_id: Option<String>,
540    #[serde(default)]
541    pub gateway_id: Option<String>,
542    pub main: bool,
543    pub state: String,
544}
545
546#[derive(Debug, Clone, Serialize, Deserialize)]
547pub struct KeyPairView {
548    pub key_pair_id: String,
549    pub key_name: String,
550    pub fingerprint: String,
551    pub tags: HashMap<String, String>,
552}
553
554// ---------------------------------------------------------------------------
555// New view structs
556// ---------------------------------------------------------------------------
557
558#[derive(Debug, Clone, Serialize, Deserialize)]
559pub struct NetworkAclView {
560    pub network_acl_id: String,
561    pub vpc_id: String,
562    pub is_default: bool,
563    pub entries: Vec<NetworkAclEntryView>,
564    pub associations: Vec<NetworkAclAssociationView>,
565    pub tags: HashMap<String, String>,
566}
567
568#[derive(Debug, Clone, Serialize, Deserialize)]
569pub struct NetworkAclEntryView {
570    pub rule_number: i32,
571    pub protocol: String,
572    pub rule_action: String,
573    pub egress: bool,
574    pub cidr_block: Option<String>,
575    pub ipv6_cidr_block: Option<String>,
576    pub port_range: Option<PortRangeView>,
577    pub icmp_type_code: Option<IcmpTypeCodeView>,
578}
579
580#[derive(Debug, Clone, Serialize, Deserialize)]
581pub struct PortRangeView {
582    pub from: i32,
583    pub to: i32,
584}
585
586#[derive(Debug, Clone, Serialize, Deserialize)]
587pub struct IcmpTypeCodeView {
588    pub type_num: i32,
589    pub code: i32,
590}
591
592#[derive(Debug, Clone, Serialize, Deserialize)]
593pub struct NetworkAclAssociationView {
594    pub network_acl_association_id: String,
595    pub network_acl_id: String,
596    pub subnet_id: String,
597}
598
599#[derive(Debug, Clone, Serialize, Deserialize)]
600pub struct ElasticIpView {
601    pub allocation_id: String,
602    pub public_ip: String,
603    pub association_id: Option<String>,
604    pub instance_id: Option<String>,
605    pub network_interface_id: Option<String>,
606    pub private_ip_address: Option<String>,
607    #[serde(default)]
608    pub address_attribute_ptr_record: Option<String>,
609    #[serde(default = "default_eip_domain")]
610    pub domain: String,
611    #[serde(default)]
612    pub pending_transfer: Option<String>,
613    pub tags: HashMap<String, String>,
614}
615
616fn default_eip_domain() -> String {
617    "vpc".to_string()
618}
619
620#[derive(Debug, Clone, Serialize, Deserialize)]
621pub struct NatGatewayView {
622    pub nat_gateway_id: String,
623    pub vpc_id: String,
624    pub subnet_id: String,
625    pub state: String,
626    pub connectivity_type: String,
627    pub allocation_id: Option<String>,
628    pub public_ip: Option<String>,
629    #[serde(default)]
630    pub secondary_addresses: Vec<NatGatewayAddressAssociationView>,
631    pub tags: HashMap<String, String>,
632}
633
634#[derive(Debug, Clone, Serialize, Deserialize)]
635pub struct NatGatewayAddressAssociationView {
636    #[serde(default)]
637    pub allocation_id: Option<String>,
638    #[serde(default)]
639    pub association_id: Option<String>,
640    #[serde(default)]
641    pub network_interface_id: Option<String>,
642    #[serde(default)]
643    pub private_ip: Option<String>,
644    #[serde(default)]
645    pub public_ip: Option<String>,
646    pub status: String,
647    #[serde(default)]
648    pub is_primary: bool,
649}
650
651#[derive(Debug, Clone, Serialize, Deserialize)]
652pub struct ByoipCidrView {
653    pub cidr: String,
654    #[serde(default)]
655    pub description: Option<String>,
656    pub state: String,
657    #[serde(default)]
658    pub asn_association: Option<AsnAssociationView>,
659    #[serde(default)]
660    pub ipam_pool_id: Option<String>,
661}
662
663#[derive(Debug, Clone, Serialize, Deserialize)]
664pub struct AsnAssociationView {
665    pub asn: String,
666    pub cidr: String,
667    pub state: String,
668    #[serde(default)]
669    pub status_message: Option<String>,
670}
671
672#[derive(Debug, Clone, Serialize, Deserialize)]
673pub struct PublicIpv4PoolView {
674    pub pool_id: String,
675    #[serde(default)]
676    pub description: Option<String>,
677    #[serde(default)]
678    pub network_border_group: Option<String>,
679    pub total_address_count: i32,
680    pub total_available_address_count: i32,
681    #[serde(default)]
682    pub pool_address_ranges: Vec<PublicIpv4PoolRangeView>,
683    #[serde(default)]
684    pub tags: HashMap<String, String>,
685}
686
687#[derive(Debug, Clone, Serialize, Deserialize)]
688pub struct PublicIpv4PoolRangeView {
689    pub first_address: String,
690    pub last_address: String,
691    pub address_count: i32,
692    pub available_address_count: i32,
693}
694
695#[derive(Debug, Clone, Serialize, Deserialize)]
696pub struct CoipCidrView {
697    pub cidr: String,
698    pub coip_pool_id: String,
699}
700
701#[derive(Debug, Clone, Serialize, Deserialize)]
702pub struct AddressTransferView {
703    pub allocation_id: String,
704    pub public_ip: String,
705    pub transfer_account_id: String,
706    pub transfer_offer_expiration_timestamp: String,
707    #[serde(default)]
708    pub transfer_offer_accepted_timestamp: Option<String>,
709    pub address_transfer_status: String,
710}
711
712#[derive(Debug, Clone, Serialize, Deserialize)]
713pub struct DhcpOptionsView {
714    pub dhcp_options_id: String,
715    pub configurations: Vec<DhcpConfigurationView>,
716    pub tags: HashMap<String, String>,
717}
718
719#[derive(Debug, Clone, Serialize, Deserialize)]
720pub struct DhcpConfigurationView {
721    pub key: String,
722    pub values: Vec<String>,
723}
724
725#[derive(Debug, Clone, Serialize, Deserialize)]
726pub struct EgressOnlyIgwView {
727    pub eigw_id: String,
728    pub state: String,
729    pub attachments: Vec<EoigwAttachmentView>,
730    pub tags: HashMap<String, String>,
731}
732
733#[derive(Debug, Clone, Serialize, Deserialize)]
734pub struct EoigwAttachmentView {
735    pub vpc_id: String,
736    pub state: String,
737}
738
739#[derive(Debug, Clone, Serialize, Deserialize)]
740pub struct FlowLogView {
741    pub flow_log_id: String,
742    pub resource_id: String,
743    pub traffic_type: String,
744    pub log_destination_type: String,
745    pub log_destination: Option<String>,
746    pub log_group_name: Option<String>,
747    pub deliver_logs_status: String,
748    pub flow_log_status: String,
749    pub tags: HashMap<String, String>,
750}
751
752#[derive(Debug, Clone, Serialize, Deserialize)]
753pub struct VpcPeeringConnectionView {
754    pub peering_id: String,
755    pub requester_vpc_id: String,
756    pub accepter_vpc_id: Option<String>,
757    pub status: String,
758    pub tags: HashMap<String, String>,
759    #[serde(default)]
760    pub requester_peering_options: Option<VpcPeeringConnectionOptionsView>,
761    #[serde(default)]
762    pub accepter_peering_options: Option<VpcPeeringConnectionOptionsView>,
763}
764
765#[derive(Debug, Clone, Default, Serialize, Deserialize)]
766pub struct VpcPeeringConnectionOptionsView {
767    #[serde(default)]
768    pub allow_dns_resolution_from_remote_vpc: bool,
769    #[serde(default)]
770    pub allow_egress_from_local_classic_link_to_remote_vpc: bool,
771    #[serde(default)]
772    pub allow_egress_from_local_vpc_to_remote_classic_link: bool,
773}
774
775#[derive(Debug, Clone, Serialize, Deserialize)]
776pub struct VpcEndpointView {
777    pub endpoint_id: String,
778    pub vpc_id: String,
779    pub service_name: String,
780    pub endpoint_type: String,
781    pub state: String,
782    pub policy_document: Option<String>,
783    pub route_table_ids: Vec<String>,
784    pub subnet_ids: Vec<String>,
785    pub security_group_ids: Vec<String>,
786    #[serde(default)]
787    pub private_dns_enabled: Option<bool>,
788    pub tags: HashMap<String, String>,
789}
790
791#[derive(Debug, Clone, Serialize, Deserialize)]
792pub struct ManagedPrefixListView {
793    pub prefix_list_id: String,
794    pub prefix_list_name: String,
795    pub state: String,
796    pub address_family: String,
797    pub max_entries: i32,
798    pub entries: Vec<PrefixListEntryView>,
799    pub tags: HashMap<String, String>,
800    pub version: i64,
801    #[serde(default)]
802    pub version_history: Vec<ManagedPrefixListVersionView>,
803}
804
805#[derive(Debug, Clone, Serialize, Deserialize)]
806pub struct ManagedPrefixListVersionView {
807    pub version: i64,
808    pub entries: Vec<PrefixListEntryView>,
809}
810
811#[derive(Debug, Clone, Serialize, Deserialize)]
812pub struct PrefixListEntryView {
813    pub cidr: String,
814    pub description: Option<String>,
815}
816
817#[derive(Debug, Clone, Serialize, Deserialize)]
818pub struct CustomerGatewayView {
819    pub customer_gateway_id: String,
820    pub bgp_asn: String,
821    pub ip_address: String,
822    pub gateway_type: String,
823    pub state: String,
824    pub tags: HashMap<String, String>,
825}
826
827#[derive(Debug, Clone, Serialize, Deserialize)]
828pub struct VpnGatewayView {
829    pub vpn_gateway_id: String,
830    pub gateway_type: String,
831    pub state: String,
832    pub amazon_side_asn: Option<i64>,
833    pub vpc_attachments: Vec<VgwVpcAttachmentView>,
834    pub tags: HashMap<String, String>,
835}
836
837#[derive(Debug, Clone, Serialize, Deserialize)]
838pub struct VgwVpcAttachmentView {
839    pub vpc_id: String,
840    pub state: String,
841}
842
843#[derive(Debug, Clone, Serialize, Deserialize)]
844pub struct VpnConnectionView {
845    pub vpn_connection_id: String,
846    pub vpn_gateway_id: String,
847    pub customer_gateway_id: String,
848    #[serde(default)]
849    pub transit_gateway_id: Option<String>,
850    pub connection_type: String,
851    pub state: String,
852    pub tags: HashMap<String, String>,
853    #[serde(default)]
854    pub routes: Vec<VpnStaticRouteView>,
855    #[serde(default)]
856    pub options: Option<VpnConnectionOptionsView>,
857    #[serde(default)]
858    pub tunnel_replacement_status: Option<String>,
859}
860
861#[derive(Debug, Clone, Serialize, Deserialize)]
862pub struct VpnStaticRouteView {
863    pub destination_cidr_block: String,
864    pub source: String,
865    pub state: String,
866}
867
868#[derive(Debug, Clone, Default, Serialize, Deserialize)]
869pub struct VpnConnectionOptionsView {
870    #[serde(default)]
871    pub local_ipv4_network_cidr: Option<String>,
872    #[serde(default)]
873    pub local_ipv6_network_cidr: Option<String>,
874    #[serde(default)]
875    pub remote_ipv4_network_cidr: Option<String>,
876    #[serde(default)]
877    pub remote_ipv6_network_cidr: Option<String>,
878    #[serde(default)]
879    pub tunnel_inside_ip_version: Option<String>,
880    #[serde(default)]
881    pub static_routes_only: Option<bool>,
882    #[serde(default)]
883    pub tunnel_options: Vec<VpnTunnelOptionsView>,
884}
885
886#[derive(Debug, Clone, Default, Serialize, Deserialize)]
887pub struct VpnTunnelOptionsView {
888    #[serde(default)]
889    pub tunnel_inside_cidr: Option<String>,
890    #[serde(default)]
891    pub tunnel_inside_ipv6_cidr: Option<String>,
892    #[serde(default)]
893    pub pre_shared_key: Option<String>,
894    #[serde(default)]
895    pub outside_ip_address: Option<String>,
896    #[serde(default)]
897    pub certificate_arn: Option<String>,
898}
899
900#[derive(Debug, Clone, Serialize, Deserialize)]
901pub struct VpnConcentratorView {
902    pub vpn_concentrator_id: String,
903    pub concentrator_type: String,
904    pub state: String,
905    #[serde(default)]
906    pub transit_gateway_id: Option<String>,
907    #[serde(default)]
908    pub transit_gateway_attachment_id: Option<String>,
909    #[serde(default)]
910    pub tags: HashMap<String, String>,
911}
912
913#[derive(Debug, Clone, Serialize, Deserialize)]
914pub struct VpcEndpointConnectionView {
915    pub service_id: String,
916    pub vpc_endpoint_id: String,
917    pub vpc_endpoint_owner: String,
918    pub vpc_endpoint_state: String,
919    pub creation_timestamp: String,
920}
921
922#[derive(Debug, Clone, Serialize, Deserialize)]
923pub struct VpcEndpointConnectionNotificationView {
924    pub connection_notification_id: String,
925    pub connection_notification_arn: String,
926    #[serde(default)]
927    pub connection_events: Vec<String>,
928    pub connection_notification_state: String,
929    pub connection_notification_type: String,
930    #[serde(default)]
931    pub service_id: Option<String>,
932    #[serde(default)]
933    pub vpc_endpoint_id: Option<String>,
934}
935
936#[derive(Debug, Clone, Serialize, Deserialize)]
937pub struct VpcBlockPublicAccessExclusionView {
938    pub exclusion_id: String,
939    pub internet_gateway_exclusion_mode: String,
940    pub resource_arn: String,
941    pub state: String,
942    pub creation_timestamp: String,
943    pub last_update_timestamp: String,
944    #[serde(default)]
945    pub tags: HashMap<String, String>,
946}
947
948#[derive(Debug, Clone, Serialize, Deserialize)]
949pub struct VpcBlockPublicAccessOptionsView {
950    pub aws_account_id: String,
951    pub aws_region: String,
952    pub internet_gateway_block_mode: String,
953    pub state: String,
954    pub last_update_timestamp: String,
955}
956
957#[derive(Debug, Clone, Serialize, Deserialize)]
958pub struct VpcEncryptionControlView {
959    pub vpc_encryption_control_id: String,
960    pub vpc_id: String,
961    pub mode: String,
962    pub state: String,
963    #[serde(default)]
964    pub mode_history: Vec<(String, String)>,
965    #[serde(default)]
966    pub tags: HashMap<String, String>,
967}
968
969#[derive(Debug, Clone, Serialize, Deserialize)]
970pub struct CarrierGatewayView {
971    pub carrier_gateway_id: String,
972    pub vpc_id: String,
973    pub state: String,
974    pub tags: HashMap<String, String>,
975}
976
977#[derive(Debug, Clone, Serialize, Deserialize)]
978pub struct NetworkInterfaceView {
979    pub network_interface_id: String,
980    pub subnet_id: String,
981    pub vpc_id: String,
982    pub description: String,
983    pub private_ip_address: String,
984    pub status: String,
985    pub attachment_id: Option<String>,
986    pub instance_id: Option<String>,
987    pub device_index: Option<i32>,
988    pub security_groups: Vec<String>,
989    #[serde(default = "default_true")]
990    pub source_dest_check: bool,
991    pub tags: HashMap<String, String>,
992    #[serde(default)]
993    pub public_ip_dns_hostname_type: Option<String>,
994}
995
996fn default_true() -> bool {
997    true
998}
999
1000#[derive(Debug, Clone, Serialize, Deserialize)]
1001pub struct TransitGatewayView {
1002    pub transit_gateway_id: String,
1003    pub state: String,
1004    pub amazon_side_asn: i64,
1005    pub description: String,
1006    pub dns_support: String,
1007    pub vpn_ecmp_support: String,
1008    pub multicast_support: String,
1009    pub tags: HashMap<String, String>,
1010}
1011
1012#[derive(Debug, Clone, Serialize, Deserialize)]
1013pub struct TgwVpcAttachmentView {
1014    pub attachment_id: String,
1015    pub transit_gateway_id: String,
1016    pub vpc_id: String,
1017    pub subnet_ids: Vec<String>,
1018    pub state: String,
1019    pub tags: HashMap<String, String>,
1020}
1021
1022#[derive(Debug, Clone, Serialize, Deserialize)]
1023pub struct TgwPeeringAttachmentView {
1024    pub attachment_id: String,
1025    pub transit_gateway_id: String,
1026    pub peer_transit_gateway_id: String,
1027    pub peer_account_id: String,
1028    pub peer_region: String,
1029    pub state: String,
1030    pub tags: HashMap<String, String>,
1031}
1032
1033#[derive(Debug, Clone, Serialize, Deserialize)]
1034pub struct TgwRouteTableView {
1035    pub route_table_id: String,
1036    pub transit_gateway_id: String,
1037    pub state: String,
1038    pub default_association_route_table: bool,
1039    pub default_propagation_route_table: bool,
1040    pub tags: HashMap<String, String>,
1041}
1042
1043#[derive(Debug, Clone, Serialize, Deserialize)]
1044pub struct TgwRouteView {
1045    pub destination_cidr_block: String,
1046    pub route_type: String,
1047    pub state: String,
1048    pub attachment_id: Option<String>,
1049}
1050
1051// --- Group 11: Transit Gateway extension view types ---
1052
1053#[derive(Debug, Clone, Serialize, Deserialize)]
1054pub struct TransitGatewayMulticastDomainView {
1055    pub transit_gateway_multicast_domain_id: String,
1056    pub transit_gateway_id: String,
1057    pub transit_gateway_multicast_domain_arn: String,
1058    pub owner_id: String,
1059    pub igmpv2_support: String,
1060    pub static_sources_support: String,
1061    pub auto_accept_shared_associations: String,
1062    pub state: String,
1063    pub creation_time: String,
1064    #[serde(default)]
1065    pub tags: HashMap<String, String>,
1066}
1067
1068#[derive(Debug, Clone, Serialize, Deserialize)]
1069pub struct MulticastSubnetAssociationView {
1070    pub subnet_id: String,
1071    pub state: String,
1072}
1073
1074#[derive(Debug, Clone, Serialize, Deserialize)]
1075pub struct TransitGatewayMulticastDomainAssociationView {
1076    pub transit_gateway_multicast_domain_id: String,
1077    pub transit_gateway_attachment_id: String,
1078    pub resource_id: String,
1079    pub resource_type: String,
1080    #[serde(default)]
1081    pub subnets: Vec<MulticastSubnetAssociationView>,
1082}
1083
1084#[derive(Debug, Clone, Serialize, Deserialize)]
1085pub struct TransitGatewayMulticastGroupMemberView {
1086    pub transit_gateway_multicast_domain_id: String,
1087    pub group_ip_address: String,
1088    pub transit_gateway_attachment_id: Option<String>,
1089    pub subnet_id: Option<String>,
1090    pub resource_id: Option<String>,
1091    pub resource_type: String,
1092    pub network_interface_id: String,
1093    pub member_type: String,
1094    pub source_type: String,
1095}
1096
1097#[derive(Debug, Clone, Serialize, Deserialize)]
1098pub struct TransitGatewayMulticastGroupSourceView {
1099    pub transit_gateway_multicast_domain_id: String,
1100    pub group_ip_address: String,
1101    pub transit_gateway_attachment_id: Option<String>,
1102    pub subnet_id: Option<String>,
1103    pub resource_id: Option<String>,
1104    pub resource_type: String,
1105    pub network_interface_id: String,
1106    pub member_type: String,
1107    pub source_type: String,
1108}
1109
1110#[derive(Debug, Clone, Serialize, Deserialize)]
1111pub struct TransitGatewayConnectView {
1112    pub transit_gateway_attachment_id: String,
1113    pub transport_transit_gateway_attachment_id: String,
1114    pub transit_gateway_id: String,
1115    pub state: String,
1116    pub creation_time: String,
1117    pub protocol: String,
1118    #[serde(default)]
1119    pub tags: HashMap<String, String>,
1120}
1121
1122#[derive(Debug, Clone, Serialize, Deserialize)]
1123pub struct TransitGatewayAttachmentBgpConfigurationView {
1124    pub transit_gateway_asn: i64,
1125    pub peer_asn: i64,
1126    pub transit_gateway_address: String,
1127    pub peer_address: String,
1128    pub bgp_status: String,
1129}
1130
1131#[derive(Debug, Clone, Serialize, Deserialize)]
1132pub struct TransitGatewayConnectPeerView {
1133    pub transit_gateway_attachment_id: String,
1134    pub transit_gateway_connect_peer_id: String,
1135    pub state: String,
1136    pub creation_time: String,
1137    pub transit_gateway_address: String,
1138    pub peer_address: String,
1139    #[serde(default)]
1140    pub inside_cidr_blocks: Vec<String>,
1141    pub protocol: String,
1142    #[serde(default)]
1143    pub bgp_configurations: Vec<TransitGatewayAttachmentBgpConfigurationView>,
1144    #[serde(default)]
1145    pub tags: HashMap<String, String>,
1146}
1147
1148#[derive(Debug, Clone, Serialize, Deserialize)]
1149pub struct TransitGatewayMeteringPolicyView {
1150    pub transit_gateway_metering_policy_id: String,
1151    pub transit_gateway_metering_policy_arn: String,
1152    pub transit_gateway_id: String,
1153    pub name: String,
1154    pub description: Option<String>,
1155    pub state: String,
1156    #[serde(default)]
1157    pub tags: HashMap<String, String>,
1158    pub last_updated_time: String,
1159    pub version: i32,
1160    #[serde(default)]
1161    pub middlebox_attachment_ids: Vec<String>,
1162}
1163
1164#[derive(Debug, Clone, Serialize, Deserialize)]
1165pub struct TransitGatewayMeteringPolicyEntryView {
1166    pub transit_gateway_metering_policy_entry_id: String,
1167    pub transit_gateway_metering_policy_id: String,
1168    pub sequence_number: i32,
1169    pub action: String,
1170    pub source_cidr_block: Option<String>,
1171    pub destination_cidr_block: Option<String>,
1172    pub protocol: Option<String>,
1173    pub source_port: Option<String>,
1174    pub destination_port: Option<String>,
1175    #[serde(default)]
1176    pub dimensions: Vec<String>,
1177    pub state: String,
1178}
1179
1180#[derive(Debug, Clone, Serialize, Deserialize)]
1181pub struct TransitGatewayPolicyTableView {
1182    pub transit_gateway_policy_table_id: String,
1183    pub transit_gateway_id: String,
1184    pub state: String,
1185    pub creation_time: String,
1186    #[serde(default)]
1187    pub tags: HashMap<String, String>,
1188}
1189
1190#[derive(Debug, Clone, Serialize, Deserialize)]
1191pub struct TransitGatewayPolicyTableAssociationView {
1192    pub transit_gateway_policy_table_id: String,
1193    pub transit_gateway_attachment_id: String,
1194    pub resource_type: String,
1195    pub resource_id: String,
1196    pub state: String,
1197}
1198
1199#[derive(Debug, Clone, Serialize, Deserialize)]
1200pub struct TransitGatewayPrefixListReferenceView {
1201    pub transit_gateway_route_table_id: String,
1202    pub prefix_list_id: String,
1203    pub prefix_list_owner_id: String,
1204    pub state: String,
1205    pub blackhole: bool,
1206    pub transit_gateway_attachment_id: Option<String>,
1207    pub resource_id: Option<String>,
1208    pub resource_type: Option<String>,
1209}
1210
1211#[derive(Debug, Clone, Serialize, Deserialize)]
1212pub struct TransitGatewayRouteTableAnnouncementView {
1213    pub transit_gateway_route_table_announcement_id: String,
1214    pub transit_gateway_id: String,
1215    pub core_network_id: String,
1216    pub peer_transit_gateway_id: String,
1217    pub peer_core_network_id: Option<String>,
1218    pub peering_attachment_id: String,
1219    pub announcement_direction: String,
1220    pub transit_gateway_route_table_id: String,
1221    pub state: String,
1222    pub creation_time: String,
1223    #[serde(default)]
1224    pub tags: HashMap<String, String>,
1225}
1226
1227#[derive(Debug, Clone, Serialize, Deserialize)]
1228pub struct InstanceStateView {
1229    pub code: i32,
1230    pub name: String,
1231}
1232
1233#[derive(Debug, Clone, Serialize, Deserialize)]
1234pub struct InstanceView {
1235    pub instance_id: String,
1236    pub image_id: String,
1237    pub instance_type: String,
1238    pub state: InstanceStateView,
1239    pub private_ip_address: Option<String>,
1240    pub public_ip_address: Option<String>,
1241    pub subnet_id: Option<String>,
1242    pub vpc_id: Option<String>,
1243    pub key_name: Option<String>,
1244    pub security_groups: Vec<String>,
1245    pub launch_time: String,
1246    pub tags: HashMap<String, String>,
1247    pub iam_instance_profile_arn: Option<String>,
1248    pub monitoring_state: String,
1249    pub placement_az: String,
1250    #[serde(default)]
1251    pub placement_group_name: Option<String>,
1252    #[serde(default)]
1253    pub placement_tenancy: Option<String>,
1254    #[serde(default)]
1255    pub placement_host_id: Option<String>,
1256    #[serde(default)]
1257    pub placement_affinity: Option<String>,
1258    #[serde(default)]
1259    pub placement_partition_number: Option<i32>,
1260    pub owner_id: String,
1261    #[serde(default)]
1262    pub classic_link_vpc: Option<(String, Vec<String>)>,
1263    #[serde(default)]
1264    pub private_dns_hostname_type: Option<String>,
1265    #[serde(default)]
1266    pub enable_resource_name_dns_a_record: Option<bool>,
1267    #[serde(default)]
1268    pub enable_resource_name_dns_aaaa_record: Option<bool>,
1269    #[serde(default)]
1270    pub credit_specification: Option<String>,
1271    #[serde(default)]
1272    pub cpu_options: Option<InstanceCpuOptionsView>,
1273    #[serde(default)]
1274    pub maintenance_options: Option<InstanceMaintenanceOptionsView>,
1275    #[serde(default)]
1276    pub network_bandwidth_weighting: Option<String>,
1277    #[serde(default)]
1278    pub lifecycle: Option<String>,
1279    #[serde(default)]
1280    pub product_codes: Vec<(String, String)>,
1281    #[serde(default)]
1282    pub capacity_reservation_specification: Option<CapacityReservationSpecificationResponseView>,
1283}
1284
1285#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1286pub struct InstanceCpuOptionsView {
1287    #[serde(default)]
1288    pub core_count: Option<i32>,
1289    #[serde(default)]
1290    pub threads_per_core: Option<i32>,
1291    #[serde(default)]
1292    pub amd_sev_snp: Option<String>,
1293}
1294
1295#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1296pub struct InstanceMaintenanceOptionsView {
1297    #[serde(default)]
1298    pub auto_recovery: Option<String>,
1299    #[serde(default)]
1300    pub reboot_migration: Option<String>,
1301}
1302
1303#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1304pub struct InstanceMetadataDefaultsView {
1305    #[serde(default)]
1306    pub http_tokens: Option<String>,
1307    #[serde(default)]
1308    pub http_put_response_hop_limit: Option<i32>,
1309    #[serde(default)]
1310    pub http_endpoint: Option<String>,
1311    #[serde(default)]
1312    pub instance_metadata_tags: Option<String>,
1313}
1314
1315#[derive(Debug, Clone, Serialize, Deserialize)]
1316pub struct VolumeAttachmentView {
1317    pub volume_id: String,
1318    pub instance_id: String,
1319    pub device: String,
1320    pub state: String,
1321    pub attach_time: String,
1322    pub delete_on_termination: bool,
1323}
1324
1325#[derive(Debug, Clone, Serialize, Deserialize)]
1326pub struct VolumeView {
1327    pub volume_id: String,
1328    pub size: i32,
1329    pub snapshot_id: Option<String>,
1330    pub availability_zone: String,
1331    pub state: String,
1332    pub volume_type: String,
1333    pub iops: Option<i32>,
1334    pub throughput: Option<i32>,
1335    pub encrypted: bool,
1336    pub create_time: String,
1337    pub attachments: Vec<VolumeAttachmentView>,
1338    pub tags: HashMap<String, String>,
1339    #[serde(default)]
1340    pub recycle_bin_state: Option<String>,
1341    #[serde(default)]
1342    pub source_volume_id: Option<String>,
1343}
1344
1345#[derive(Debug, Clone, Serialize, Deserialize)]
1346pub struct SnapshotView {
1347    pub snapshot_id: String,
1348    pub volume_id: String,
1349    pub volume_size: i32,
1350    pub state: String,
1351    pub description: String,
1352    pub start_time: String,
1353    pub progress: String,
1354    pub owner_id: String,
1355    pub encrypted: bool,
1356    pub tags: HashMap<String, String>,
1357    #[serde(default = "default_lock_state")]
1358    pub lock_state: String,
1359    #[serde(default)]
1360    pub lock_duration: Option<i32>,
1361    #[serde(default)]
1362    pub lock_created_on: Option<String>,
1363    #[serde(default)]
1364    pub lock_expires_on: Option<String>,
1365    #[serde(default)]
1366    pub lock_duration_start_time: Option<String>,
1367    #[serde(default)]
1368    pub cool_off_period: Option<i32>,
1369    #[serde(default)]
1370    pub cool_off_period_expires_on: Option<String>,
1371    #[serde(default = "default_storage_tier")]
1372    pub storage_tier: String,
1373    #[serde(default)]
1374    pub last_tiering_operation_status: Option<String>,
1375    #[serde(default)]
1376    pub fast_snapshot_restore_states: Vec<FastSnapshotRestoreStateView>,
1377}
1378
1379#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1380pub struct FastSnapshotRestoreStateView {
1381    pub availability_zone: String,
1382    pub state: String,
1383}
1384
1385fn default_lock_state() -> String {
1386    "none".to_string()
1387}
1388
1389fn default_storage_tier() -> String {
1390    "standard".to_string()
1391}
1392
1393#[derive(Debug, Clone, Serialize, Deserialize)]
1394pub struct ImageView {
1395    pub image_id: String,
1396    pub name: String,
1397    pub description: String,
1398    pub state: String,
1399    pub owner_id: String,
1400    pub architecture: String,
1401    pub image_type: String,
1402    pub platform: Option<String>,
1403    pub virtualization_type: String,
1404    pub root_device_type: String,
1405    pub root_device_name: String,
1406    pub public: bool,
1407    pub tags: HashMap<String, String>,
1408    pub source_instance_id: Option<String>,
1409    pub source_instance_type: String,
1410    #[serde(default)]
1411    pub launch_permissions: Vec<LaunchPermissionView>,
1412    #[serde(default)]
1413    pub recycle_bin_state: Option<String>,
1414    #[serde(default)]
1415    pub deprecation_time: Option<String>,
1416    #[serde(default)]
1417    pub recycle_bin_enter_time: Option<String>,
1418    #[serde(default)]
1419    pub product_codes: Vec<(String, String)>,
1420    #[serde(default)]
1421    pub fast_launch_state: Option<FastLaunchStateView>,
1422    #[serde(default)]
1423    pub deregistration_protection: Option<String>,
1424    #[serde(default)]
1425    pub kernel_id: Option<String>,
1426    #[serde(default)]
1427    pub ramdisk_id: Option<String>,
1428    #[serde(default)]
1429    pub ena_support: Option<bool>,
1430    #[serde(default)]
1431    pub sriov_net_support: Option<String>,
1432    #[serde(default)]
1433    pub tpm_support: Option<String>,
1434    #[serde(default)]
1435    pub boot_mode: Option<String>,
1436    #[serde(default)]
1437    pub imds_support: Option<String>,
1438    #[serde(default)]
1439    pub image_location: Option<String>,
1440    #[serde(default)]
1441    pub source_image_id: Option<String>,
1442    #[serde(default)]
1443    pub source_region: Option<String>,
1444}
1445
1446#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1447pub struct FastLaunchStateView {
1448    pub state: String,
1449    pub image_id: String,
1450    pub resource_type: String,
1451    pub snapshot_configuration: SnapshotConfigurationRequestView,
1452    pub launch_template: FastLaunchLaunchTemplateSpecificationView,
1453    pub max_parallel_launches: i32,
1454    pub owner_id: String,
1455    pub state_transition_time: String,
1456}
1457
1458#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1459pub struct SnapshotConfigurationRequestView {
1460    #[serde(default)]
1461    pub target_resource_count: Option<i32>,
1462}
1463
1464#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1465pub struct FastLaunchLaunchTemplateSpecificationView {
1466    #[serde(default)]
1467    pub launch_template_id: Option<String>,
1468    #[serde(default)]
1469    pub launch_template_name: Option<String>,
1470    #[serde(default)]
1471    pub version: Option<String>,
1472}
1473
1474#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1475pub struct LaunchPermissionView {
1476    #[serde(default, skip_serializing_if = "Option::is_none")]
1477    pub user_id: Option<String>,
1478    #[serde(default, skip_serializing_if = "Option::is_none")]
1479    pub group: Option<String>,
1480}
1481
1482#[derive(Debug, Clone, Serialize, Deserialize)]
1483pub struct LaunchTemplateView {
1484    pub launch_template_id: String,
1485    pub launch_template_name: String,
1486    pub default_version_number: i64,
1487    pub latest_version_number: i64,
1488    pub tags: HashMap<String, String>,
1489}
1490
1491#[derive(Debug, Clone, Serialize, Deserialize)]
1492pub struct LaunchTemplateVersionView {
1493    pub version_number: i64,
1494    pub launch_template_id: String,
1495    pub launch_template_name: String,
1496    pub version_description: String,
1497    pub data: HashMap<String, String>,
1498    pub default_version: bool,
1499}
1500
1501#[derive(Debug, Clone, Serialize, Deserialize)]
1502pub struct SpotInstanceRequestView {
1503    pub spot_instance_request_id: String,
1504    pub spot_price: String,
1505    pub instance_type: String,
1506    pub image_id: String,
1507    pub state: String,
1508    pub status_code: String,
1509    pub instance_id: Option<String>,
1510    pub tags: HashMap<String, String>,
1511}
1512
1513#[derive(Debug, Clone, Serialize, Deserialize)]
1514pub struct SpotDatafeedSubscriptionView {
1515    pub bucket: String,
1516    #[serde(default)]
1517    pub prefix: Option<String>,
1518    pub owner_id: String,
1519    pub state: String,
1520}
1521
1522#[derive(Debug, Clone, Serialize, Deserialize)]
1523pub struct IamInstanceProfileAssociationView {
1524    pub association_id: String,
1525    pub instance_id: String,
1526    pub iam_instance_profile_arn: String,
1527    pub iam_instance_profile_name: String,
1528    pub state: String,
1529}
1530
1531#[derive(Debug, Clone, Serialize, Deserialize)]
1532pub struct DedicatedHostView {
1533    pub host_id: String,
1534    pub availability_zone: String,
1535    pub instance_type: Option<String>,
1536    pub auto_placement: String,
1537    pub host_recovery: String,
1538    pub state: String,
1539    pub tags: HashMap<String, String>,
1540}
1541
1542#[derive(Debug, Clone, Serialize, Deserialize)]
1543pub struct Ec2FleetView {
1544    pub fleet_id: String,
1545    pub state: String,
1546    pub fleet_type: String,
1547    pub create_time: String,
1548    pub tags: HashMap<String, String>,
1549    #[serde(default)]
1550    pub total_target_capacity: Option<i32>,
1551    #[serde(default)]
1552    pub on_demand_target_capacity: Option<i32>,
1553    #[serde(default)]
1554    pub spot_target_capacity: Option<i32>,
1555    #[serde(default)]
1556    pub context: Option<String>,
1557}
1558
1559#[derive(Debug, Clone, Serialize, Deserialize)]
1560pub struct VpcEndpointServiceConfigView {
1561    pub service_id: String,
1562    pub service_name: String,
1563    pub service_type: String,
1564    pub acceptance_required: bool,
1565    pub state: String,
1566    pub network_load_balancer_arns: Vec<String>,
1567    pub gateway_load_balancer_arns: Vec<String>,
1568    pub allowed_principals: Vec<String>,
1569    pub tags: HashMap<String, String>,
1570    #[serde(default)]
1571    pub payer_responsibility: Option<String>,
1572    #[serde(default)]
1573    pub private_dns_state: Option<String>,
1574}
1575
1576#[derive(Debug, Clone, Serialize, Deserialize)]
1577pub struct SpotFleetRequestView {
1578    pub spot_fleet_request_id: String,
1579    pub spot_fleet_request_state: String,
1580    pub target_capacity: i32,
1581    pub iam_fleet_role: String,
1582    pub create_time: String,
1583    pub tags: HashMap<String, String>,
1584}
1585
1586#[derive(Debug, Clone, Serialize, Deserialize)]
1587pub struct SubnetCidrReservationView {
1588    pub reservation_id: String,
1589    pub subnet_id: String,
1590    pub cidr: String,
1591    pub reservation_type: String,
1592    pub description: String,
1593    pub owner_id: String,
1594}
1595
1596#[derive(Debug, Clone, Serialize, Deserialize)]
1597pub struct PlacementGroupView {
1598    pub group_id: String,
1599    pub group_name: String,
1600    pub group_arn: String,
1601    pub strategy: String,
1602    pub state: String,
1603    #[serde(default)]
1604    pub partition_count: Option<i32>,
1605    #[serde(default)]
1606    pub spread_level: Option<String>,
1607    #[serde(default)]
1608    pub tags: HashMap<String, String>,
1609}
1610
1611#[derive(Debug, Clone, Serialize, Deserialize)]
1612pub struct NetworkInterfacePermissionView {
1613    pub network_interface_permission_id: String,
1614    pub network_interface_id: String,
1615    #[serde(default)]
1616    pub aws_account_id: Option<String>,
1617    #[serde(default)]
1618    pub aws_service: Option<String>,
1619    pub permission: String,
1620    pub permission_state: String,
1621}
1622
1623#[derive(Debug, Clone, Serialize, Deserialize)]
1624pub struct CapacityReservationView {
1625    pub capacity_reservation_id: String,
1626    pub capacity_reservation_arn: String,
1627    pub owner_id: String,
1628    pub instance_type: String,
1629    pub instance_platform: String,
1630    pub availability_zone: String,
1631    pub tenancy: String,
1632    pub total_instance_count: i32,
1633    pub available_instance_count: i32,
1634    pub ebs_optimized: bool,
1635    pub ephemeral_storage: bool,
1636    pub state: String,
1637    pub start_date: String,
1638    #[serde(default)]
1639    pub end_date: Option<String>,
1640    pub end_date_type: String,
1641    pub instance_match_criteria: String,
1642    pub create_date: String,
1643    #[serde(default)]
1644    pub outpost_arn: Option<String>,
1645    #[serde(default)]
1646    pub placement_group_arn: Option<String>,
1647    #[serde(default)]
1648    pub tags: HashMap<String, String>,
1649    #[serde(default)]
1650    pub pending_billing_owner_account_id: Option<String>,
1651    #[serde(default)]
1652    pub billing_owner_account_id: Option<String>,
1653    #[serde(default)]
1654    pub target_capacity_reservation_id: Option<String>,
1655    #[serde(default)]
1656    pub reservation_type: Option<String>,
1657    #[serde(default)]
1658    pub commitment_info: Option<CapacityReservationCommitmentInfoView>,
1659}
1660
1661#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1662pub struct CapacityReservationCommitmentInfoView {
1663    #[serde(default)]
1664    pub commitment_end_date: Option<String>,
1665    #[serde(default)]
1666    pub committed_instance_count: Option<i32>,
1667}
1668
1669#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1670pub struct CapacityReservationSpecificationResponseView {
1671    #[serde(default)]
1672    pub capacity_reservation_preference: Option<String>,
1673    #[serde(default)]
1674    pub capacity_reservation_id: Option<String>,
1675    #[serde(default)]
1676    pub capacity_reservation_resource_group_arn: Option<String>,
1677}
1678
1679#[derive(Debug, Clone, Serialize, Deserialize)]
1680pub struct BillingOwnershipOfferView {
1681    pub capacity_reservation_id: String,
1682    pub unused_reservation_billing_owner_id: String,
1683    pub requested_by: String,
1684    pub status: String,
1685    #[serde(default)]
1686    pub status_message: Option<String>,
1687    pub last_update_time: String,
1688}
1689
1690#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1691pub struct S3DestinationOptionsView {
1692    pub bucket: String,
1693    #[serde(default)]
1694    pub prefix: Option<String>,
1695}
1696
1697#[derive(Debug, Clone, Serialize, Deserialize)]
1698pub struct CapacityManagerDataExportView {
1699    pub data_export_id: String,
1700    pub schedule: String,
1701    #[serde(default)]
1702    pub organization_account_ids: Vec<String>,
1703    pub output_format: String,
1704    pub s3_destination: S3DestinationOptionsView,
1705    pub status: String,
1706    #[serde(default)]
1707    pub status_message: Option<String>,
1708    #[serde(default)]
1709    pub last_export_time: Option<String>,
1710    #[serde(default)]
1711    pub next_export_time: Option<String>,
1712    pub create_time: String,
1713    #[serde(default)]
1714    pub tags: HashMap<String, String>,
1715}
1716
1717#[derive(Debug, Clone, Serialize, Deserialize)]
1718pub struct CapacityManagerOrganizationsAccessView {
1719    pub state: String,
1720    pub last_updated_time: String,
1721}
1722
1723#[derive(Debug, Clone, Serialize, Deserialize)]
1724pub struct InterruptibleCapacityReservationAllocationView {
1725    pub allocation_id: String,
1726    pub capacity_reservation_id: String,
1727    pub instance_count: i32,
1728    pub start_date_time: String,
1729    pub end_date_time: String,
1730    pub state: String,
1731    pub allocation_type: String,
1732    #[serde(default)]
1733    pub tags: HashMap<String, String>,
1734}
1735
1736#[derive(Debug, Clone, Serialize, Deserialize)]
1737pub struct CapacityBlockView {
1738    pub capacity_block_id: String,
1739    pub capacity_reservation_id: String,
1740    pub capacity_block_offering_id: String,
1741    pub instance_type: String,
1742    pub instance_count: i32,
1743    pub availability_zone: String,
1744    pub start_date: String,
1745    pub end_date: String,
1746    pub tenancy: String,
1747    pub currency_code: String,
1748    pub upfront_fee: String,
1749    pub commitment_duration_in_seconds: i64,
1750    pub capacity_reservation_arn: String,
1751    #[serde(default)]
1752    pub tags: HashMap<String, String>,
1753}
1754
1755#[derive(Debug, Clone, Serialize, Deserialize)]
1756pub struct CapacityBlockExtensionView {
1757    pub capacity_block_extension_id: String,
1758    pub capacity_reservation_id: String,
1759    pub instance_type: String,
1760    pub availability_zone: String,
1761    pub instance_count: i32,
1762    #[serde(default)]
1763    pub availability_zone_id: Option<String>,
1764    pub start_date: String,
1765    pub end_date: String,
1766    pub capacity_block_extension_offering_id: String,
1767    pub capacity_block_extension_status: String,
1768    pub capacity_block_extension_purchase_date: String,
1769    pub capacity_block_extension_duration_hours: i32,
1770    pub currency_code: String,
1771    pub upfront_fee: String,
1772    #[serde(default)]
1773    pub capacity_reservation_arn: Option<String>,
1774    #[serde(default)]
1775    pub capacity_block_extension_arn: Option<String>,
1776}
1777
1778#[derive(Debug, Clone, Serialize, Deserialize)]
1779pub struct CapacityReservationFleetInstanceSpecView {
1780    pub instance_type: String,
1781    pub instance_platform: String,
1782    #[serde(default)]
1783    pub availability_zone: Option<String>,
1784    #[serde(default)]
1785    pub ebs_optimized: Option<bool>,
1786    #[serde(default)]
1787    pub priority: Option<i32>,
1788    #[serde(default)]
1789    pub weight: Option<f64>,
1790}
1791
1792#[derive(Debug, Clone, Serialize, Deserialize)]
1793pub struct CapacityReservationFleetView {
1794    pub capacity_reservation_fleet_id: String,
1795    pub capacity_reservation_fleet_arn: String,
1796    pub state: String,
1797    pub tenancy: String,
1798    pub allocation_strategy: String,
1799    pub instance_match_criteria: String,
1800    pub total_target_capacity: i32,
1801    pub total_fulfilled_capacity: f64,
1802    pub create_time: String,
1803    #[serde(default)]
1804    pub end_date: Option<String>,
1805    #[serde(default)]
1806    pub instance_type_specifications: Vec<CapacityReservationFleetInstanceSpecView>,
1807    #[serde(default)]
1808    pub tags: HashMap<String, String>,
1809}
1810
1811#[derive(Debug, Clone, Serialize, Deserialize)]
1812pub struct InstanceConnectEndpointView {
1813    pub instance_connect_endpoint_id: String,
1814    pub instance_connect_endpoint_arn: String,
1815    pub subnet_id: String,
1816    pub vpc_id: String,
1817    pub availability_zone: String,
1818    pub state: String,
1819    pub created_at: String,
1820    pub preserve_client_ip: bool,
1821    #[serde(default)]
1822    pub security_group_ids: Vec<String>,
1823    #[serde(default)]
1824    pub network_interface_ids: Vec<String>,
1825    pub dns_name: String,
1826    pub fips_dns_name: String,
1827    pub ip_address_type: String,
1828    pub owner_id: String,
1829    #[serde(default)]
1830    pub tags: HashMap<String, String>,
1831}
1832
1833#[derive(Debug, Clone, Serialize, Deserialize)]
1834pub struct CoipPoolView {
1835    pub pool_id: String,
1836    pub pool_arn: String,
1837    pub local_gateway_route_table_id: String,
1838    #[serde(default)]
1839    pub pool_cidrs: Vec<String>,
1840    #[serde(default)]
1841    pub tags: HashMap<String, String>,
1842}
1843
1844#[derive(Debug, Clone, Serialize, Deserialize)]
1845pub struct SecurityGroupVpcAssociationView {
1846    pub group_id: String,
1847    pub vpc_id: String,
1848    pub vpc_owner_id: String,
1849    pub state: String,
1850}
1851
1852#[derive(Debug, Clone, Serialize, Deserialize)]
1853pub struct EnclaveCertificateIamRoleAssociationView {
1854    pub certificate_arn: String,
1855    pub role_arn: String,
1856    pub certificate_s3_bucket_name: String,
1857    pub certificate_s3_object_key: String,
1858    pub encryption_kms_key_id: String,
1859}
1860
1861#[derive(Debug, Clone, Serialize, Deserialize)]
1862pub struct MacSipModificationTaskView {
1863    pub task_id: String,
1864    pub instance_id: String,
1865    pub task_type: String,
1866    pub task_state: String,
1867    pub start_time: String,
1868    #[serde(default)]
1869    pub apple_internal: Option<String>,
1870    #[serde(default)]
1871    pub base_system: Option<String>,
1872    #[serde(default)]
1873    pub debugging_restrictions: Option<String>,
1874    #[serde(default)]
1875    pub dtrace_restrictions: Option<String>,
1876    #[serde(default)]
1877    pub filesystem_protections: Option<String>,
1878    #[serde(default)]
1879    pub kext_signing: Option<String>,
1880    #[serde(default)]
1881    pub nvram_protections: Option<String>,
1882    #[serde(default)]
1883    pub status: Option<String>,
1884    #[serde(default)]
1885    pub tags: HashMap<String, String>,
1886}
1887
1888#[derive(Debug, Clone, Serialize, Deserialize)]
1889pub struct DeclarativePoliciesReportView {
1890    pub report_id: String,
1891    pub s3_bucket: String,
1892    #[serde(default)]
1893    pub s3_prefix: Option<String>,
1894    pub target_id: String,
1895    pub status: String,
1896    pub start_time: String,
1897    #[serde(default)]
1898    pub end_time: Option<String>,
1899    #[serde(default)]
1900    pub tags: HashMap<String, String>,
1901}
1902
1903// ===== Group 6: Network Insights view types =====
1904
1905#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1906pub struct PathStatementSpecView {
1907    #[serde(default)]
1908    pub packet_header_statement: Option<PacketHeaderStatementSpecView>,
1909    #[serde(default)]
1910    pub resource_statement: Option<ResourceStatementSpecView>,
1911}
1912
1913#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1914pub struct PacketHeaderStatementSpecView {
1915    #[serde(default)]
1916    pub destination_addresses: Vec<String>,
1917    #[serde(default)]
1918    pub destination_ports: Vec<String>,
1919    #[serde(default)]
1920    pub destination_prefix_lists: Vec<String>,
1921    #[serde(default)]
1922    pub protocols: Vec<String>,
1923    #[serde(default)]
1924    pub source_addresses: Vec<String>,
1925    #[serde(default)]
1926    pub source_ports: Vec<String>,
1927    #[serde(default)]
1928    pub source_prefix_lists: Vec<String>,
1929}
1930
1931#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1932pub struct ResourceStatementSpecView {
1933    #[serde(default)]
1934    pub resource_types: Vec<String>,
1935    #[serde(default)]
1936    pub resources: Vec<String>,
1937}
1938
1939#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1940pub struct AccessScopePathSpecView {
1941    #[serde(default)]
1942    pub source: Option<PathStatementSpecView>,
1943    #[serde(default)]
1944    pub destination: Option<PathStatementSpecView>,
1945    #[serde(default)]
1946    pub through_resources: Vec<ResourceStatementSpecView>,
1947}
1948
1949#[derive(Debug, Clone, Serialize, Deserialize)]
1950pub struct NetworkInsightsAccessScopeView {
1951    pub network_insights_access_scope_id: String,
1952    pub network_insights_access_scope_arn: String,
1953    pub created_date: String,
1954    pub updated_date: String,
1955    pub tags: HashMap<String, String>,
1956    #[serde(default)]
1957    pub match_paths: Vec<AccessScopePathSpecView>,
1958    #[serde(default)]
1959    pub exclude_paths: Vec<AccessScopePathSpecView>,
1960}
1961
1962#[derive(Debug, Clone, Serialize, Deserialize)]
1963pub struct NetworkInsightsAccessScopeAnalysisView {
1964    pub network_insights_access_scope_analysis_id: String,
1965    pub network_insights_access_scope_analysis_arn: String,
1966    pub network_insights_access_scope_id: String,
1967    pub status: String,
1968    pub status_message: Option<String>,
1969    pub warning_message: Option<String>,
1970    pub start_date: String,
1971    pub end_date: Option<String>,
1972    pub findings_found: String,
1973    pub analyzed_eni_count: i32,
1974    pub tags: HashMap<String, String>,
1975}
1976
1977#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1978pub struct NetworkInsightsPathFilterPortRangeView {
1979    pub from_port: Option<i32>,
1980    pub to_port: Option<i32>,
1981}
1982
1983#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1984pub struct NetworkInsightsPathFilterView {
1985    pub destination_address: Option<String>,
1986    pub destination_port_range: Option<NetworkInsightsPathFilterPortRangeView>,
1987    pub source_address: Option<String>,
1988    pub source_port_range: Option<NetworkInsightsPathFilterPortRangeView>,
1989}
1990
1991#[derive(Debug, Clone, Serialize, Deserialize)]
1992pub struct NetworkInsightsPathView {
1993    pub network_insights_path_id: String,
1994    pub network_insights_path_arn: String,
1995    pub created_date: String,
1996    pub source: Option<String>,
1997    pub destination: Option<String>,
1998    pub source_arn: Option<String>,
1999    pub destination_arn: Option<String>,
2000    pub source_ip: Option<String>,
2001    pub destination_ip: Option<String>,
2002    pub protocol: String,
2003    pub destination_port: Option<i32>,
2004    pub tags: HashMap<String, String>,
2005    #[serde(default)]
2006    pub filter_at_source: NetworkInsightsPathFilterView,
2007    #[serde(default)]
2008    pub filter_at_destination: NetworkInsightsPathFilterView,
2009}
2010
2011#[derive(Debug, Clone, Serialize, Deserialize)]
2012pub struct NetworkInsightsAnalysisView {
2013    pub network_insights_analysis_id: String,
2014    pub network_insights_analysis_arn: String,
2015    pub network_insights_path_id: String,
2016    #[serde(default)]
2017    pub additional_accounts: Vec<String>,
2018    #[serde(default)]
2019    pub filter_in_arns: Vec<String>,
2020    pub start_date: String,
2021    pub end_date: Option<String>,
2022    pub status: String,
2023    pub status_message: Option<String>,
2024    pub warning_message: Option<String>,
2025    pub network_path_found: bool,
2026    pub tags: HashMap<String, String>,
2027}
2028
2029// ===== Group 6: Traffic Mirror view types =====
2030
2031#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2032pub struct TrafficMirrorPortRangeView {
2033    pub from_port: Option<i32>,
2034    pub to_port: Option<i32>,
2035}
2036
2037#[derive(Debug, Clone, Serialize, Deserialize)]
2038pub struct TrafficMirrorFilterRuleView {
2039    pub traffic_mirror_filter_rule_id: String,
2040    pub traffic_mirror_filter_id: String,
2041    pub traffic_direction: String,
2042    pub rule_number: i32,
2043    pub rule_action: String,
2044    pub protocol: Option<i32>,
2045    pub destination_port_range: Option<TrafficMirrorPortRangeView>,
2046    pub source_port_range: Option<TrafficMirrorPortRangeView>,
2047    pub destination_cidr_block: String,
2048    pub source_cidr_block: String,
2049    pub description: Option<String>,
2050    pub tags: HashMap<String, String>,
2051}
2052
2053#[derive(Debug, Clone, Serialize, Deserialize)]
2054pub struct TrafficMirrorFilterView {
2055    pub traffic_mirror_filter_id: String,
2056    pub description: Option<String>,
2057    #[serde(default)]
2058    pub ingress_filter_rules: Vec<TrafficMirrorFilterRuleView>,
2059    #[serde(default)]
2060    pub egress_filter_rules: Vec<TrafficMirrorFilterRuleView>,
2061    #[serde(default)]
2062    pub network_services: Vec<String>,
2063    pub tags: HashMap<String, String>,
2064}
2065
2066#[derive(Debug, Clone, Serialize, Deserialize)]
2067pub struct TrafficMirrorSessionView {
2068    pub traffic_mirror_session_id: String,
2069    pub traffic_mirror_target_id: String,
2070    pub traffic_mirror_filter_id: String,
2071    pub network_interface_id: String,
2072    pub owner_id: String,
2073    pub packet_length: Option<i32>,
2074    pub session_number: i32,
2075    pub virtual_network_id: Option<i32>,
2076    pub description: Option<String>,
2077    pub tags: HashMap<String, String>,
2078}
2079
2080#[derive(Debug, Clone, Serialize, Deserialize)]
2081pub struct TrafficMirrorTargetView {
2082    pub traffic_mirror_target_id: String,
2083    pub network_interface_id: Option<String>,
2084    pub network_load_balancer_arn: Option<String>,
2085    pub gateway_load_balancer_endpoint_id: Option<String>,
2086    pub r#type: String,
2087    pub description: Option<String>,
2088    pub owner_id: String,
2089    pub tags: HashMap<String, String>,
2090}
2091
2092// ===== Group 7: Client VPN view types =====
2093
2094#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2095pub struct ClientVpnEndpointStatusView {
2096    pub code: String,
2097    pub message: Option<String>,
2098}
2099
2100#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2101pub struct ClientVpnAuthorizationRuleStatusView {
2102    pub code: String,
2103    pub message: Option<String>,
2104}
2105
2106#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2107pub struct ClientVpnRouteStatusView {
2108    pub code: String,
2109    pub message: Option<String>,
2110}
2111
2112#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2113pub struct ClientVpnAssociationStatusView {
2114    pub code: String,
2115    pub message: Option<String>,
2116}
2117
2118#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2119pub struct ClientVpnConnectionStatusView {
2120    pub code: String,
2121    pub message: Option<String>,
2122}
2123
2124#[derive(Debug, Clone, Serialize, Deserialize)]
2125pub struct ClientVpnEndpointView {
2126    pub client_vpn_endpoint_id: String,
2127    pub description: Option<String>,
2128    pub status: ClientVpnEndpointStatusView,
2129    pub creation_time: String,
2130    pub deletion_time: Option<String>,
2131    pub dns_name: String,
2132    pub client_cidr_block: String,
2133    #[serde(default)]
2134    pub dns_servers: Vec<String>,
2135    pub split_tunnel: bool,
2136    pub vpn_protocol: String,
2137    pub transport_protocol: String,
2138    pub vpn_port: i32,
2139    pub server_certificate_arn: String,
2140    #[serde(default)]
2141    pub authentication_options: Vec<String>,
2142    pub connection_log_options_enabled: bool,
2143    pub connection_log_options_cloudwatch_log_group: Option<String>,
2144    pub connection_log_options_cloudwatch_log_stream: Option<String>,
2145    pub tags: HashMap<String, String>,
2146    #[serde(default)]
2147    pub security_group_ids: Vec<String>,
2148    pub vpc_id: Option<String>,
2149    pub self_service_portal_url: Option<String>,
2150    pub self_service_portal: String,
2151    pub session_timeout_hours: i32,
2152    pub client_login_banner_enabled: bool,
2153    pub client_login_banner_text: Option<String>,
2154    pub disconnect_on_session_timeout: bool,
2155    pub client_route_enforcement_enforced: bool,
2156    pub client_certificate_revocation_list: Option<String>,
2157}
2158
2159#[derive(Debug, Clone, Serialize, Deserialize)]
2160pub struct ClientVpnTargetNetworkAssociationView {
2161    pub association_id: String,
2162    pub vpc_id: String,
2163    pub target_network_id: String,
2164    pub client_vpn_endpoint_id: String,
2165    #[serde(default)]
2166    pub security_groups: Vec<String>,
2167    pub status: ClientVpnAssociationStatusView,
2168}
2169
2170#[derive(Debug, Clone, Serialize, Deserialize)]
2171pub struct ClientVpnAuthorizationRuleView {
2172    pub client_vpn_endpoint_id: String,
2173    pub group_id: Option<String>,
2174    pub access_all: bool,
2175    pub destination_cidr: String,
2176    pub description: Option<String>,
2177    pub status: ClientVpnAuthorizationRuleStatusView,
2178}
2179
2180#[derive(Debug, Clone, Serialize, Deserialize)]
2181pub struct ClientVpnRouteView {
2182    pub client_vpn_endpoint_id: String,
2183    pub destination_cidr: String,
2184    pub target_subnet: String,
2185    pub r#type: String,
2186    pub origin: String,
2187    pub status: ClientVpnRouteStatusView,
2188    pub description: Option<String>,
2189}
2190
2191#[derive(Debug, Clone, Serialize, Deserialize)]
2192pub struct ClientVpnConnectionView {
2193    pub connection_id: String,
2194    pub client_vpn_endpoint_id: String,
2195    pub username: Option<String>,
2196    pub status: ClientVpnConnectionStatusView,
2197    #[serde(default)]
2198    pub posture_compliance_statuses: Vec<String>,
2199    pub common_name: Option<String>,
2200    pub connection_established_time: String,
2201    pub connection_end_time: Option<String>,
2202    pub ingress_bytes: String,
2203    pub egress_bytes: String,
2204    pub ingress_packets: String,
2205    pub egress_packets: String,
2206    pub client_ip: Option<String>,
2207    pub client_port: Option<String>,
2208    pub timestamp: String,
2209}
2210
2211// ===== Group 7: Local Gateway view types =====
2212
2213#[derive(Debug, Clone, Serialize, Deserialize)]
2214pub struct LocalGatewayView {
2215    pub local_gateway_id: String,
2216    pub outpost_arn: String,
2217    pub owner_id: String,
2218    pub state: String,
2219    pub tags: HashMap<String, String>,
2220}
2221
2222#[derive(Debug, Clone, Serialize, Deserialize)]
2223pub struct LocalGatewayRouteView {
2224    pub destination_cidr_block: String,
2225    pub local_gateway_route_table_id: String,
2226    pub r#type: String,
2227    pub state: String,
2228    pub local_gateway_route_table_arn: Option<String>,
2229    pub owner_id: String,
2230    pub subnet_id: Option<String>,
2231    pub network_interface_id: Option<String>,
2232    pub destination_prefix_list_id: Option<String>,
2233    pub coip_pool_id: Option<String>,
2234    pub local_gateway_virtual_interface_group_id: Option<String>,
2235}
2236
2237#[derive(Debug, Clone, Serialize, Deserialize)]
2238pub struct LocalGatewayRouteTableView {
2239    pub local_gateway_route_table_id: String,
2240    pub local_gateway_route_table_arn: String,
2241    pub local_gateway_id: String,
2242    pub owner_id: String,
2243    pub state: String,
2244    pub mode: String,
2245    pub tags: HashMap<String, String>,
2246    pub state_reason_code: Option<String>,
2247    pub state_reason_message: Option<String>,
2248}
2249
2250#[derive(Debug, Clone, Serialize, Deserialize)]
2251pub struct LocalGatewayRouteTableVirtualInterfaceGroupAssociationView {
2252    pub local_gateway_route_table_virtual_interface_group_association_id: String,
2253    pub local_gateway_virtual_interface_group_id: String,
2254    pub local_gateway_route_table_id: String,
2255    pub local_gateway_route_table_arn: String,
2256    pub local_gateway_id: String,
2257    pub owner_id: String,
2258    pub state: String,
2259    pub tags: HashMap<String, String>,
2260}
2261
2262#[derive(Debug, Clone, Serialize, Deserialize)]
2263pub struct LocalGatewayRouteTableVpcAssociationView {
2264    pub local_gateway_route_table_vpc_association_id: String,
2265    pub local_gateway_route_table_id: String,
2266    pub local_gateway_route_table_arn: String,
2267    pub local_gateway_id: String,
2268    pub vpc_id: String,
2269    pub owner_id: String,
2270    pub state: String,
2271    pub tags: HashMap<String, String>,
2272}
2273
2274#[derive(Debug, Clone, Serialize, Deserialize)]
2275pub struct LocalGatewayVirtualInterfaceView {
2276    pub local_gateway_virtual_interface_id: String,
2277    pub local_gateway_id: String,
2278    pub vlan: i32,
2279    pub local_address: String,
2280    pub peer_address: String,
2281    pub local_bgp_asn: i32,
2282    pub peer_bgp_asn: i32,
2283    pub owner_id: String,
2284    pub tags: HashMap<String, String>,
2285    pub configuration_state: String,
2286    pub peer_bgp_asn_extended: Option<i64>,
2287    pub local_gateway_virtual_interface_arn: Option<String>,
2288}
2289
2290#[derive(Debug, Clone, Serialize, Deserialize)]
2291pub struct LocalGatewayVirtualInterfaceGroupView {
2292    pub local_gateway_virtual_interface_group_id: String,
2293    #[serde(default)]
2294    pub local_gateway_virtual_interface_ids: Vec<String>,
2295    pub local_gateway_id: String,
2296    pub owner_id: String,
2297    pub tags: HashMap<String, String>,
2298    pub configuration_state: Option<String>,
2299    pub local_bgp_asn: i32,
2300    pub local_bgp_asn_extended: Option<i64>,
2301    pub local_gateway_virtual_interface_group_arn: Option<String>,
2302}
2303
2304// ===== Group 8: Route Server view types =====
2305
2306#[derive(Debug, Clone, Serialize, Deserialize)]
2307pub struct RouteServerView {
2308    pub route_server_id: String,
2309    pub route_server_arn: String,
2310    pub amazon_side_asn: i64,
2311    pub state: String,
2312    pub persist_routes: String,
2313    pub persist_routes_duration: Option<i64>,
2314    pub sns_notifications_enabled: bool,
2315    pub sns_topic_arn: Option<String>,
2316    pub tags: HashMap<String, String>,
2317}
2318
2319#[derive(Debug, Clone, Serialize, Deserialize)]
2320pub struct RouteServerEndpointView {
2321    pub route_server_endpoint_id: String,
2322    pub route_server_id: String,
2323    pub vpc_id: String,
2324    pub subnet_id: String,
2325    pub eni_id: String,
2326    pub eni_address: Option<String>,
2327    pub state: String,
2328    pub failure_reason: Option<String>,
2329    pub tags: HashMap<String, String>,
2330}
2331
2332#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2333pub struct RouteServerBgpOptionsView {
2334    pub peer_asn: Option<i64>,
2335    pub peer_liveness_detection: Option<String>,
2336}
2337
2338#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2339pub struct RouteServerPeerOptionsView {
2340    pub peer_asn: i64,
2341    pub peer_liveness_detection: String,
2342    pub bgp_options: Option<RouteServerBgpOptionsView>,
2343}
2344
2345#[derive(Debug, Clone, Serialize, Deserialize)]
2346pub struct RouteServerPeerView {
2347    pub route_server_peer_id: String,
2348    pub route_server_endpoint_id: String,
2349    pub route_server_id: String,
2350    pub vpc_id: String,
2351    pub subnet_id: String,
2352    pub peer_address: String,
2353    pub state: String,
2354    pub failure_reason: Option<String>,
2355    pub options: RouteServerPeerOptionsView,
2356    pub endpoint_eni_id: Option<String>,
2357    pub endpoint_eni_address: Option<String>,
2358    pub tags: HashMap<String, String>,
2359}
2360
2361#[derive(Debug, Clone, Serialize, Deserialize)]
2362pub struct RouteServerAssociationView {
2363    pub route_server_id: String,
2364    pub vpc_id: String,
2365    pub state: String,
2366    #[serde(default)]
2367    pub propagations: Vec<String>,
2368}
2369
2370// ===== Group 9: Verified Access view types =====
2371
2372#[derive(Debug, Clone, Serialize, Deserialize)]
2373pub struct VerifiedAccessInstanceView {
2374    pub verified_access_instance_id: String,
2375    #[serde(default)]
2376    pub description: Option<String>,
2377    pub creation_time: String,
2378    pub last_updated_time: String,
2379    #[serde(default)]
2380    pub fips_enabled: bool,
2381    #[serde(default)]
2382    pub cidr_endpoints_custom_subdomain: Option<String>,
2383    #[serde(default)]
2384    pub name: Option<String>,
2385    #[serde(default)]
2386    pub trust_provider_ids: Vec<String>,
2387    #[serde(default)]
2388    pub tags: HashMap<String, String>,
2389}
2390
2391#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2392pub struct VerifiedAccessOidcOptionsView {
2393    #[serde(default)]
2394    pub issuer: Option<String>,
2395    #[serde(default)]
2396    pub authorization_endpoint: Option<String>,
2397    #[serde(default)]
2398    pub token_endpoint: Option<String>,
2399    #[serde(default)]
2400    pub user_info_endpoint: Option<String>,
2401    #[serde(default)]
2402    pub client_id: Option<String>,
2403    #[serde(default)]
2404    pub client_secret: Option<String>,
2405    #[serde(default)]
2406    pub scope: Option<String>,
2407}
2408
2409#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2410pub struct VerifiedAccessDeviceOptionsView {
2411    #[serde(default)]
2412    pub tenant_id: Option<String>,
2413    #[serde(default)]
2414    pub public_signing_key_url: Option<String>,
2415}
2416
2417#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2418pub struct VerifiedAccessNativeApplicationOidcOptionsView {
2419    #[serde(default)]
2420    pub public_signing_key_endpoint: Option<String>,
2421    #[serde(default)]
2422    pub issuer: Option<String>,
2423    #[serde(default)]
2424    pub authorization_endpoint: Option<String>,
2425    #[serde(default)]
2426    pub token_endpoint: Option<String>,
2427    #[serde(default)]
2428    pub user_info_endpoint: Option<String>,
2429    #[serde(default)]
2430    pub client_id: Option<String>,
2431    #[serde(default)]
2432    pub client_secret: Option<String>,
2433    #[serde(default)]
2434    pub scope: Option<String>,
2435}
2436
2437#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2438pub struct VerifiedAccessSseSpecificationView {
2439    #[serde(default)]
2440    pub customer_managed_key_enabled: Option<bool>,
2441    #[serde(default)]
2442    pub kms_key_arn: Option<String>,
2443}
2444
2445#[derive(Debug, Clone, Serialize, Deserialize)]
2446pub struct VerifiedAccessTrustProviderView {
2447    pub verified_access_trust_provider_id: String,
2448    #[serde(default)]
2449    pub description: Option<String>,
2450    pub trust_provider_type: String,
2451    #[serde(default)]
2452    pub user_trust_provider_type: Option<String>,
2453    #[serde(default)]
2454    pub device_trust_provider_type: Option<String>,
2455    #[serde(default)]
2456    pub oidc_options: Option<VerifiedAccessOidcOptionsView>,
2457    #[serde(default)]
2458    pub device_options: Option<VerifiedAccessDeviceOptionsView>,
2459    #[serde(default)]
2460    pub native_application_oidc_options: Option<VerifiedAccessNativeApplicationOidcOptionsView>,
2461    pub policy_reference_name: String,
2462    pub creation_time: String,
2463    pub last_updated_time: String,
2464    #[serde(default)]
2465    pub sse_specification: VerifiedAccessSseSpecificationView,
2466    #[serde(default)]
2467    pub tags: HashMap<String, String>,
2468}
2469
2470#[derive(Debug, Clone, Serialize, Deserialize)]
2471pub struct VerifiedAccessGroupView {
2472    pub verified_access_group_id: String,
2473    pub verified_access_group_arn: String,
2474    pub verified_access_instance_id: String,
2475    pub owner: String,
2476    #[serde(default)]
2477    pub description: Option<String>,
2478    pub creation_time: String,
2479    pub last_updated_time: String,
2480    #[serde(default)]
2481    pub deletion_time: Option<String>,
2482    #[serde(default)]
2483    pub sse_specification: VerifiedAccessSseSpecificationView,
2484    #[serde(default)]
2485    pub policy_document: Option<String>,
2486    #[serde(default)]
2487    pub policy_enabled: bool,
2488    #[serde(default)]
2489    pub tags: HashMap<String, String>,
2490}
2491
2492#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2493pub struct VerifiedAccessEndpointPortRangeView {
2494    #[serde(default)]
2495    pub from_port: Option<i32>,
2496    #[serde(default)]
2497    pub to_port: Option<i32>,
2498}
2499
2500#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2501pub struct VerifiedAccessEndpointLoadBalancerOptionsView {
2502    #[serde(default)]
2503    pub load_balancer_arn: Option<String>,
2504    #[serde(default)]
2505    pub port: Option<i32>,
2506    #[serde(default)]
2507    pub port_ranges: Vec<VerifiedAccessEndpointPortRangeView>,
2508    #[serde(default)]
2509    pub protocol: Option<String>,
2510    #[serde(default)]
2511    pub subnet_ids: Vec<String>,
2512}
2513
2514#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2515pub struct VerifiedAccessEndpointEniOptionsView {
2516    #[serde(default)]
2517    pub network_interface_id: Option<String>,
2518    #[serde(default)]
2519    pub port: Option<i32>,
2520    #[serde(default)]
2521    pub port_ranges: Vec<VerifiedAccessEndpointPortRangeView>,
2522    #[serde(default)]
2523    pub protocol: Option<String>,
2524}
2525
2526#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2527pub struct VerifiedAccessEndpointCidrOptionsView {
2528    #[serde(default)]
2529    pub cidr: Option<String>,
2530    #[serde(default)]
2531    pub port_ranges: Vec<VerifiedAccessEndpointPortRangeView>,
2532    #[serde(default)]
2533    pub protocol: Option<String>,
2534    #[serde(default)]
2535    pub subnet_ids: Vec<String>,
2536}
2537
2538#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2539pub struct VerifiedAccessEndpointRdsOptionsView {
2540    #[serde(default)]
2541    pub port: Option<i32>,
2542    #[serde(default)]
2543    pub protocol: Option<String>,
2544    #[serde(default)]
2545    pub rds_db_cluster_arn: Option<String>,
2546    #[serde(default)]
2547    pub rds_db_instance_arn: Option<String>,
2548    #[serde(default)]
2549    pub rds_db_proxy_arn: Option<String>,
2550    #[serde(default)]
2551    pub rds_endpoint: Option<String>,
2552    #[serde(default)]
2553    pub subnet_ids: Vec<String>,
2554}
2555
2556#[derive(Debug, Clone, Serialize, Deserialize)]
2557pub struct VerifiedAccessEndpointView {
2558    pub verified_access_endpoint_id: String,
2559    pub verified_access_instance_id: String,
2560    pub verified_access_group_id: String,
2561    #[serde(default)]
2562    pub application_domain: Option<String>,
2563    pub endpoint_type: String,
2564    pub attachment_type: String,
2565    #[serde(default)]
2566    pub domain_certificate_arn: Option<String>,
2567    #[serde(default)]
2568    pub endpoint_domain: Option<String>,
2569    #[serde(default)]
2570    pub device_validation_domain: Option<String>,
2571    #[serde(default)]
2572    pub security_group_ids: Vec<String>,
2573    #[serde(default)]
2574    pub load_balancer_options: Option<VerifiedAccessEndpointLoadBalancerOptionsView>,
2575    #[serde(default)]
2576    pub network_interface_options: Option<VerifiedAccessEndpointEniOptionsView>,
2577    #[serde(default)]
2578    pub cidr_options: Option<VerifiedAccessEndpointCidrOptionsView>,
2579    #[serde(default)]
2580    pub rds_options: Option<VerifiedAccessEndpointRdsOptionsView>,
2581    pub status_code: String,
2582    #[serde(default)]
2583    pub status_message: Option<String>,
2584    #[serde(default)]
2585    pub description: Option<String>,
2586    pub creation_time: String,
2587    pub last_updated_time: String,
2588    #[serde(default)]
2589    pub deletion_time: Option<String>,
2590    #[serde(default)]
2591    pub sse_specification: VerifiedAccessSseSpecificationView,
2592    #[serde(default)]
2593    pub policy_document: Option<String>,
2594    #[serde(default)]
2595    pub policy_enabled: bool,
2596    #[serde(default)]
2597    pub tags: HashMap<String, String>,
2598}
2599
2600#[derive(Debug, Clone, Serialize, Deserialize)]
2601pub struct VerifiedAccessTrustProviderAttachmentView {
2602    pub instance_id: String,
2603    pub trust_provider_id: String,
2604}
2605
2606#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2607pub struct VerifiedAccessLogsView {
2608    #[serde(default)]
2609    pub cloud_watch_logs_enabled: bool,
2610    #[serde(default)]
2611    pub cloud_watch_logs_log_group: Option<String>,
2612    #[serde(default)]
2613    pub kinesis_data_firehose_enabled: bool,
2614    #[serde(default)]
2615    pub kinesis_data_firehose_delivery_stream: Option<String>,
2616    #[serde(default)]
2617    pub s3_enabled: bool,
2618    #[serde(default)]
2619    pub s3_bucket_name: Option<String>,
2620    #[serde(default)]
2621    pub s3_bucket_owner: Option<String>,
2622    #[serde(default)]
2623    pub s3_prefix: Option<String>,
2624    #[serde(default)]
2625    pub log_version: Option<String>,
2626    #[serde(default)]
2627    pub include_trust_context: Option<bool>,
2628}
2629
2630/// Serializable snapshot of all counters so IDs remain stable across restore.
2631#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2632pub struct CountersView {
2633    pub vpc: u32,
2634    pub subnet: u32,
2635    pub igw: u32,
2636    pub sg: u32,
2637    pub sgr: u32,
2638    pub rtb: u32,
2639    pub rtbassoc: u32,
2640    pub keypair: u32,
2641    pub nacl: u32,
2642    pub nacl_assoc: u32,
2643    pub eip: u32,
2644    #[serde(default)]
2645    pub eip_assoc: u32,
2646    pub nat: u32,
2647    pub dopt: u32,
2648    pub eigw: u32,
2649    pub flow_log: u32,
2650    pub vpc_peering: u32,
2651    pub vpc_endpoint: u32,
2652    pub prefix_list: u32,
2653    pub cgw: u32,
2654    pub vgw: u32,
2655    pub vpn: u32,
2656    pub cgw_carrier: u32,
2657    pub eni: u32,
2658    #[serde(default)]
2659    pub eni_attach: u32,
2660    pub vpc_cidr_assoc: u32,
2661    pub tgw: u32,
2662    pub tgw_attach: u32,
2663    pub tgw_rtb: u32,
2664    pub instance: u32,
2665    pub vol: u32,
2666    pub snapshot: u32,
2667    pub ami: u32,
2668    pub lt: u32,
2669    pub spot: u32,
2670    pub iam_assoc: u32,
2671    pub host: u32,
2672    pub fleet: u32,
2673    pub vpce_svc: u32,
2674    pub spot_fleet: u32,
2675    pub subnet_cidr_res: u32,
2676    pub subnet_ipv6_assoc: u32,
2677    #[serde(default)]
2678    pub placement_group: u32,
2679    #[serde(default)]
2680    pub eni_permission: u32,
2681    #[serde(default)]
2682    pub instance_connect_endpoint: u32,
2683    #[serde(default)]
2684    pub capacity_reservation: u32,
2685    #[serde(default)]
2686    pub capacity_reservation_fleet: u32,
2687    #[serde(default)]
2688    pub coip_pool: u32,
2689    #[serde(default)]
2690    pub mac_sip_task: u32,
2691    #[serde(default)]
2692    pub declarative_policies_report: u32,
2693    #[serde(default)]
2694    pub public_ipv4_pool: u32,
2695    #[serde(default)]
2696    pub address_transfer: u32,
2697    #[serde(default)]
2698    pub nat_gateway_address_assoc: u32,
2699    #[serde(default)]
2700    pub vpn_concentrator: u32,
2701    #[serde(default)]
2702    pub vpc_endpoint_connection_notification: u32,
2703    #[serde(default)]
2704    pub vpc_block_public_access_exclusion: u32,
2705    #[serde(default)]
2706    pub vpc_encryption_control: u32,
2707    #[serde(default)]
2708    pub mac_volume_ownership_task: u32,
2709    #[serde(default)]
2710    pub replace_root_volume_task: u32,
2711    #[serde(default)]
2712    pub snapshot_import_task: u32,
2713    #[serde(default)]
2714    pub conversion_task: u32,
2715    #[serde(default)]
2716    pub export_task: u32,
2717    #[serde(default)]
2718    pub import_task: u32,
2719    #[serde(default)]
2720    pub trunk_interface_assoc: u32,
2721    #[serde(default)]
2722    pub secondary_network: u32,
2723    #[serde(default)]
2724    pub secondary_subnet: u32,
2725    #[serde(default)]
2726    pub reserved_instances_exchange: u32,
2727    #[serde(default)]
2728    pub reserved_instances_listing: u32,
2729    #[serde(default)]
2730    pub reserved_instances_purchase: u32,
2731    #[serde(default)]
2732    pub reserved_instances: u32,
2733    #[serde(default)]
2734    pub reserved_instances_modification: u32,
2735    #[serde(default)]
2736    pub fpga_image: u32,
2737    #[serde(default)]
2738    pub image_usage_report: u32,
2739    #[serde(default)]
2740    pub import_image_task: u32,
2741    #[serde(default)]
2742    pub instance_event_window: u32,
2743    #[serde(default)]
2744    pub instance_event: u32,
2745    #[serde(default)]
2746    pub host_reservation: u32,
2747    #[serde(default)]
2748    pub scheduled_instance: u32,
2749    #[serde(default)]
2750    pub network_insights_access_scope: u32,
2751    #[serde(default)]
2752    pub network_insights_access_scope_analysis: u32,
2753    #[serde(default)]
2754    pub network_insights_path: u32,
2755    #[serde(default)]
2756    pub network_insights_analysis: u32,
2757    #[serde(default)]
2758    pub traffic_mirror_filter: u32,
2759    #[serde(default)]
2760    pub traffic_mirror_filter_rule: u32,
2761    #[serde(default)]
2762    pub traffic_mirror_session: u32,
2763    #[serde(default)]
2764    pub traffic_mirror_target: u32,
2765    // --- Group 7 additions ---
2766    #[serde(default)]
2767    pub client_vpn_endpoint: u32,
2768    #[serde(default)]
2769    pub client_vpn_target_network_association: u32,
2770    #[serde(default)]
2771    pub client_vpn_connection: u32,
2772    #[serde(default)]
2773    pub local_gateway: u32,
2774    #[serde(default)]
2775    pub local_gateway_route_table: u32,
2776    #[serde(default)]
2777    pub local_gateway_route_table_virtual_interface_group_association: u32,
2778    #[serde(default)]
2779    pub local_gateway_route_table_vpc_association: u32,
2780    #[serde(default)]
2781    pub local_gateway_virtual_interface: u32,
2782    #[serde(default)]
2783    pub local_gateway_virtual_interface_group: u32,
2784    // --- Group 8 additions ---
2785    #[serde(default)]
2786    pub route_server: u32,
2787    #[serde(default)]
2788    pub route_server_endpoint: u32,
2789    #[serde(default)]
2790    pub route_server_peer: u32,
2791    // --- Group 9 additions ---
2792    #[serde(default)]
2793    pub verified_access_instance: u32,
2794    #[serde(default)]
2795    pub verified_access_trust_provider: u32,
2796    #[serde(default)]
2797    pub verified_access_group: u32,
2798    #[serde(default)]
2799    pub verified_access_endpoint: u32,
2800    // --- Group 10 additions ---
2801    #[serde(default)]
2802    pub capacity_manager_data_export: u32,
2803    #[serde(default)]
2804    pub interruptible_capacity_reservation_allocation: u32,
2805    #[serde(default)]
2806    pub capacity_block: u32,
2807    #[serde(default)]
2808    pub capacity_block_extension: u32,
2809    // --- Group 11 additions ---
2810    #[serde(default)]
2811    pub tgw_multicast_domain: u32,
2812    #[serde(default)]
2813    pub tgw_connect: u32,
2814    #[serde(default)]
2815    pub tgw_connect_peer: u32,
2816    #[serde(default)]
2817    pub tgw_metering_policy: u32,
2818    #[serde(default)]
2819    pub tgw_metering_policy_entry: u32,
2820    #[serde(default)]
2821    pub tgw_policy_table: u32,
2822    #[serde(default)]
2823    pub tgw_route_table_announcement: u32,
2824    // --- Group 12 additions ---
2825    #[serde(default)]
2826    pub ipam: u32,
2827    #[serde(default)]
2828    pub ipam_scope: u32,
2829    #[serde(default)]
2830    pub ipam_pool: u32,
2831    #[serde(default)]
2832    pub ipam_pool_cidr: u32,
2833    #[serde(default)]
2834    pub ipam_pool_allocation: u32,
2835    #[serde(default)]
2836    pub ipam_resource_discovery: u32,
2837    #[serde(default)]
2838    pub ipam_resource_discovery_association: u32,
2839    #[serde(default)]
2840    pub ipam_external_resource_verification_token: u32,
2841    #[serde(default)]
2842    pub ipam_policy: u32,
2843    #[serde(default)]
2844    pub ipam_prefix_list_resolver: u32,
2845    #[serde(default)]
2846    pub ipam_prefix_list_resolver_target: u32,
2847    // --- Batch B additions ---
2848    #[serde(default)]
2849    pub bundle_task: u32,
2850    #[serde(default)]
2851    pub volume_modification: u32,
2852    #[serde(default)]
2853    pub import_volume_task: u32,
2854    #[serde(default)]
2855    pub export_image_task: u32,
2856    #[serde(default)]
2857    pub outpost_lag: u32,
2858}
2859
2860// ---------------------------------------------------------------------------
2861// From internal types to view types
2862// ---------------------------------------------------------------------------
2863
2864impl From<&Ec2State> for Ec2StateView {
2865    fn from(state: &Ec2State) -> Self {
2866        Ec2StateView {
2867            vpcs: state
2868                .vpcs
2869                .iter()
2870                .map(|(k, v)| (k.clone(), VpcView::from(v)))
2871                .collect(),
2872            subnets: state
2873                .subnets
2874                .iter()
2875                .map(|(k, v)| (k.clone(), SubnetView::from(v)))
2876                .collect(),
2877            igws: state
2878                .igws
2879                .iter()
2880                .map(|(k, v)| (k.clone(), InternetGatewayView::from(v)))
2881                .collect(),
2882            security_groups: state
2883                .security_groups
2884                .iter()
2885                .map(|(k, v)| (k.clone(), SecurityGroupView::from(v)))
2886                .collect(),
2887            route_tables: state
2888                .route_tables
2889                .iter()
2890                .map(|(k, v)| (k.clone(), RouteTableView::from(v)))
2891                .collect(),
2892            key_pairs: state
2893                .key_pairs
2894                .iter()
2895                .map(|(k, v)| (k.clone(), KeyPairView::from(v)))
2896                .collect(),
2897            network_acls: state
2898                .network_acls
2899                .iter()
2900                .map(|(k, v)| (k.clone(), NetworkAclView::from(v)))
2901                .collect(),
2902            elastic_ips: state
2903                .elastic_ips
2904                .iter()
2905                .map(|(k, v)| (k.clone(), ElasticIpView::from(v)))
2906                .collect(),
2907            nat_gateways: state
2908                .nat_gateways
2909                .iter()
2910                .map(|(k, v)| (k.clone(), NatGatewayView::from(v)))
2911                .collect(),
2912            dhcp_options: state
2913                .dhcp_options
2914                .iter()
2915                .map(|(k, v)| (k.clone(), DhcpOptionsView::from(v)))
2916                .collect(),
2917            egress_only_igws: state
2918                .egress_only_igws
2919                .iter()
2920                .map(|(k, v)| (k.clone(), EgressOnlyIgwView::from(v)))
2921                .collect(),
2922            flow_logs: state
2923                .flow_logs
2924                .iter()
2925                .map(|(k, v)| (k.clone(), FlowLogView::from(v)))
2926                .collect(),
2927            vpc_peering_connections: state
2928                .vpc_peering_connections
2929                .iter()
2930                .map(|(k, v)| (k.clone(), VpcPeeringConnectionView::from(v)))
2931                .collect(),
2932            vpc_endpoints: state
2933                .vpc_endpoints
2934                .iter()
2935                .map(|(k, v)| (k.clone(), VpcEndpointView::from(v)))
2936                .collect(),
2937            managed_prefix_lists: state
2938                .managed_prefix_lists
2939                .iter()
2940                .map(|(k, v)| (k.clone(), ManagedPrefixListView::from(v)))
2941                .collect(),
2942            customer_gateways: state
2943                .customer_gateways
2944                .iter()
2945                .map(|(k, v)| (k.clone(), CustomerGatewayView::from(v)))
2946                .collect(),
2947            vpn_gateways: state
2948                .vpn_gateways
2949                .iter()
2950                .map(|(k, v)| (k.clone(), VpnGatewayView::from(v)))
2951                .collect(),
2952            vpn_connections: state
2953                .vpn_connections
2954                .iter()
2955                .map(|(k, v)| (k.clone(), VpnConnectionView::from(v)))
2956                .collect(),
2957            carrier_gateways: state
2958                .carrier_gateways
2959                .iter()
2960                .map(|(k, v)| (k.clone(), CarrierGatewayView::from(v)))
2961                .collect(),
2962            network_interfaces: state
2963                .network_interfaces
2964                .iter()
2965                .map(|(k, v)| (k.clone(), NetworkInterfaceView::from(v)))
2966                .collect(),
2967            vpc_cidr_associations: state.vpc_cidr_associations.clone(),
2968            ebs_encryption_by_default: state.ebs_encryption_by_default,
2969            transit_gateways: state
2970                .transit_gateways
2971                .iter()
2972                .map(|(k, v)| (k.clone(), TransitGatewayView::from(v)))
2973                .collect(),
2974            tgw_vpc_attachments: state
2975                .tgw_vpc_attachments
2976                .iter()
2977                .map(|(k, v)| (k.clone(), TgwVpcAttachmentView::from(v)))
2978                .collect(),
2979            tgw_peering_attachments: state
2980                .tgw_peering_attachments
2981                .iter()
2982                .map(|(k, v)| (k.clone(), TgwPeeringAttachmentView::from(v)))
2983                .collect(),
2984            tgw_route_tables: state
2985                .tgw_route_tables
2986                .iter()
2987                .map(|(k, v)| (k.clone(), TgwRouteTableView::from(v)))
2988                .collect(),
2989            tgw_routes: state
2990                .tgw_routes
2991                .iter()
2992                .map(|(k, v)| (k.clone(), v.iter().map(TgwRouteView::from).collect()))
2993                .collect(),
2994            instances: state
2995                .instances
2996                .iter()
2997                .map(|(k, v)| (k.clone(), InstanceView::from(v)))
2998                .collect(),
2999            volumes: state
3000                .volumes
3001                .iter()
3002                .map(|(k, v)| (k.clone(), VolumeView::from(v)))
3003                .collect(),
3004            snapshots: state
3005                .snapshots
3006                .iter()
3007                .map(|(k, v)| (k.clone(), SnapshotView::from(v)))
3008                .collect(),
3009            images: state
3010                .images
3011                .iter()
3012                .map(|(k, v)| (k.clone(), ImageView::from(v)))
3013                .collect(),
3014            launch_templates: state
3015                .launch_templates
3016                .iter()
3017                .map(|(k, v)| (k.clone(), LaunchTemplateView::from(v)))
3018                .collect(),
3019            launch_template_versions: state
3020                .launch_template_versions
3021                .iter()
3022                .map(|(k, v)| {
3023                    (
3024                        k.clone(),
3025                        v.iter().map(LaunchTemplateVersionView::from).collect(),
3026                    )
3027                })
3028                .collect(),
3029            spot_requests: state
3030                .spot_requests
3031                .iter()
3032                .map(|(k, v)| (k.clone(), SpotInstanceRequestView::from(v)))
3033                .collect(),
3034            spot_datafeed_subscription: state
3035                .spot_datafeed_subscription
3036                .as_ref()
3037                .map(SpotDatafeedSubscriptionView::from),
3038            iam_instance_profile_associations: state
3039                .iam_instance_profile_associations
3040                .iter()
3041                .map(|(k, v)| (k.clone(), IamInstanceProfileAssociationView::from(v)))
3042                .collect(),
3043            dedicated_hosts: state
3044                .dedicated_hosts
3045                .iter()
3046                .map(|(k, v)| (k.clone(), DedicatedHostView::from(v)))
3047                .collect(),
3048            ec2_fleets: state
3049                .ec2_fleets
3050                .iter()
3051                .map(|(k, v)| (k.clone(), Ec2FleetView::from(v)))
3052                .collect(),
3053            vpc_endpoint_service_configs: state
3054                .vpc_endpoint_service_configs
3055                .iter()
3056                .map(|(k, v)| (k.clone(), VpcEndpointServiceConfigView::from(v)))
3057                .collect(),
3058            spot_fleet_requests: state
3059                .spot_fleet_requests
3060                .iter()
3061                .map(|(k, v)| (k.clone(), SpotFleetRequestView::from(v)))
3062                .collect(),
3063            subnet_cidr_reservations: state
3064                .subnet_cidr_reservations
3065                .iter()
3066                .map(|(k, v)| (k.clone(), SubnetCidrReservationView::from(v)))
3067                .collect(),
3068            placement_groups: state
3069                .placement_groups
3070                .iter()
3071                .map(|(k, v)| (k.clone(), PlacementGroupView::from(v)))
3072                .collect(),
3073            network_interface_permissions: state
3074                .network_interface_permissions
3075                .iter()
3076                .map(|(k, v)| (k.clone(), NetworkInterfacePermissionView::from(v)))
3077                .collect(),
3078            instance_connect_endpoints: state
3079                .instance_connect_endpoints
3080                .iter()
3081                .map(|(k, v)| (k.clone(), InstanceConnectEndpointView::from(v)))
3082                .collect(),
3083            capacity_reservations: state
3084                .capacity_reservations
3085                .iter()
3086                .map(|(k, v)| (k.clone(), CapacityReservationView::from(v)))
3087                .collect(),
3088            capacity_reservation_fleets: state
3089                .capacity_reservation_fleets
3090                .iter()
3091                .map(|(k, v)| (k.clone(), CapacityReservationFleetView::from(v)))
3092                .collect(),
3093            coip_pools: state
3094                .coip_pools
3095                .iter()
3096                .map(|(k, v)| (k.clone(), CoipPoolView::from(v)))
3097                .collect(),
3098            byoip_cidrs: state
3099                .byoip_cidrs
3100                .iter()
3101                .map(|(k, v)| (k.clone(), ByoipCidrView::from(v)))
3102                .collect(),
3103            public_ipv4_pools: state
3104                .public_ipv4_pools
3105                .iter()
3106                .map(|(k, v)| (k.clone(), PublicIpv4PoolView::from(v)))
3107                .collect(),
3108            coip_cidrs: state.coip_cidrs.values().map(CoipCidrView::from).collect(),
3109            address_transfers: state
3110                .address_transfers
3111                .iter()
3112                .map(|(k, v)| (k.clone(), AddressTransferView::from(v)))
3113                .collect(),
3114            security_group_vpc_associations: state
3115                .security_group_vpc_associations
3116                .values()
3117                .map(SecurityGroupVpcAssociationView::from)
3118                .collect(),
3119            enclave_certificate_iam_role_associations: state
3120                .enclave_certificate_iam_role_associations
3121                .values()
3122                .map(EnclaveCertificateIamRoleAssociationView::from)
3123                .collect(),
3124            mac_sip_modification_tasks: state
3125                .mac_sip_modification_tasks
3126                .iter()
3127                .map(|(k, v)| (k.clone(), MacSipModificationTaskView::from(v)))
3128                .collect(),
3129            declarative_policies_reports: state
3130                .declarative_policies_reports
3131                .iter()
3132                .map(|(k, v)| (k.clone(), DeclarativePoliciesReportView::from(v)))
3133                .collect(),
3134            vpn_concentrators: state
3135                .vpn_concentrators
3136                .iter()
3137                .map(|(k, v)| (k.clone(), VpnConcentratorView::from(v)))
3138                .collect(),
3139            vpc_endpoint_connections: state
3140                .vpc_endpoint_connections
3141                .values()
3142                .map(VpcEndpointConnectionView::from)
3143                .collect(),
3144            vpc_endpoint_connection_notifications: state
3145                .vpc_endpoint_connection_notifications
3146                .iter()
3147                .map(|(k, v)| (k.clone(), VpcEndpointConnectionNotificationView::from(v)))
3148                .collect(),
3149            vpc_block_public_access_exclusions: state
3150                .vpc_block_public_access_exclusions
3151                .iter()
3152                .map(|(k, v)| (k.clone(), VpcBlockPublicAccessExclusionView::from(v)))
3153                .collect(),
3154            vpc_block_public_access_options: state
3155                .vpc_block_public_access_options
3156                .as_ref()
3157                .map(VpcBlockPublicAccessOptionsView::from),
3158            vpc_encryption_controls: state
3159                .vpc_encryption_controls
3160                .iter()
3161                .map(|(k, v)| (k.clone(), VpcEncryptionControlView::from(v)))
3162                .collect(),
3163            mac_volume_ownership_tasks: state
3164                .mac_volume_ownership_tasks
3165                .iter()
3166                .map(|(k, v)| (k.clone(), MacVolumeOwnershipTaskView::from(v)))
3167                .collect(),
3168            replace_root_volume_tasks: state
3169                .replace_root_volume_tasks
3170                .iter()
3171                .map(|(k, v)| (k.clone(), ReplaceRootVolumeTaskView::from(v)))
3172                .collect(),
3173            snapshot_import_tasks: state
3174                .snapshot_import_tasks
3175                .iter()
3176                .map(|(k, v)| (k.clone(), SnapshotImportTaskView::from(v)))
3177                .collect(),
3178            conversion_tasks: state
3179                .conversion_tasks
3180                .iter()
3181                .map(|(k, v)| (k.clone(), ConversionTaskView::from(v)))
3182                .collect(),
3183            export_tasks: state
3184                .export_tasks
3185                .iter()
3186                .map(|(k, v)| (k.clone(), ExportTaskView::from(v)))
3187                .collect(),
3188            import_tasks: state.import_tasks.clone(),
3189            trunk_interface_associations: state
3190                .trunk_interface_associations
3191                .iter()
3192                .map(|(k, v)| (k.clone(), TrunkInterfaceAssociationView::from(v)))
3193                .collect(),
3194            secondary_networks: state
3195                .secondary_networks
3196                .iter()
3197                .map(|(k, v)| (k.clone(), SecondaryNetworkView::from(v)))
3198                .collect(),
3199            secondary_subnets: state
3200                .secondary_subnets
3201                .iter()
3202                .map(|(k, v)| (k.clone(), SecondarySubnetView::from(v)))
3203                .collect(),
3204            deleted_volumes_recycle_bin: state
3205                .deleted_volumes_recycle_bin
3206                .iter()
3207                .map(|(k, v)| (k.clone(), VolumeView::from(v)))
3208                .collect(),
3209            deleted_snapshots_recycle_bin: state
3210                .deleted_snapshots_recycle_bin
3211                .iter()
3212                .map(|(k, v)| (k.clone(), SnapshotView::from(v)))
3213                .collect(),
3214            reserved_instances_exchanges: state
3215                .reserved_instances_exchanges
3216                .iter()
3217                .map(|(k, v)| (k.clone(), ReservedInstancesExchangeView::from(v)))
3218                .collect(),
3219            reserved_instances_listings: state
3220                .reserved_instances_listings
3221                .iter()
3222                .map(|(k, v)| (k.clone(), ReservedInstancesListingView::from(v)))
3223                .collect(),
3224            queued_reserved_instances_purchases: state
3225                .queued_reserved_instances_purchases
3226                .iter()
3227                .map(|(k, v)| (k.clone(), ReservedInstancesPurchaseView::from(v)))
3228                .collect(),
3229            reserved_instances_modifications: state
3230                .reserved_instances_modifications
3231                .iter()
3232                .map(|(k, v)| (k.clone(), ReservedInstancesModificationView::from(v)))
3233                .collect(),
3234            reserved_instances_purchases: state
3235                .reserved_instances_purchases
3236                .iter()
3237                .map(|(k, v)| (k.clone(), ReservedInstancesPurchaseView::from(v)))
3238                .collect(),
3239            reserved_instances: state
3240                .reserved_instances
3241                .iter()
3242                .map(|(k, v)| (k.clone(), ReservedInstancesRecordView::from(v)))
3243                .collect(),
3244            fpga_images: state
3245                .fpga_images
3246                .iter()
3247                .map(|(k, v)| (k.clone(), FpgaImageView::from(v)))
3248                .collect(),
3249            image_usage_reports: state
3250                .image_usage_reports
3251                .iter()
3252                .map(|(k, v)| (k.clone(), ImageUsageReportView::from(v)))
3253                .collect(),
3254            restore_image_tasks: state
3255                .restore_image_tasks
3256                .iter()
3257                .map(|(k, v)| (k.clone(), RestoreImageTaskView::from(v)))
3258                .collect(),
3259            store_image_tasks: state
3260                .store_image_tasks
3261                .iter()
3262                .map(|(k, v)| (k.clone(), StoreImageTaskView::from(v)))
3263                .collect(),
3264            import_image_tasks: state
3265                .import_image_tasks
3266                .iter()
3267                .map(|(k, v)| (k.clone(), ImportImageTaskView::from(v)))
3268                .collect(),
3269            allowed_image_criteria: state
3270                .allowed_image_criteria
3271                .iter()
3272                .map(AllowedImageCriterionView::from)
3273                .collect(),
3274            default_credit_specifications: state.default_credit_specifications.clone(),
3275            instance_metadata_defaults: state
3276                .instance_metadata_defaults
3277                .as_ref()
3278                .map(InstanceMetadataDefaultsView::from),
3279            instance_event_windows: state
3280                .instance_event_windows
3281                .iter()
3282                .map(|(k, v)| (k.clone(), InstanceEventWindowView::from(v)))
3283                .collect(),
3284            instance_event_notification_attributes: state
3285                .instance_event_notification_attributes
3286                .as_ref()
3287                .map(InstanceTagNotificationAttributesView::from),
3288            instance_events: state
3289                .instance_events
3290                .iter()
3291                .map(|(k, v)| (k.clone(), InstanceEventView::from(v)))
3292                .collect(),
3293            host_reservations: state
3294                .host_reservations
3295                .iter()
3296                .map(|(k, v)| (k.clone(), HostReservationView::from(v)))
3297                .collect(),
3298            scheduled_instances: state
3299                .scheduled_instances
3300                .iter()
3301                .map(|(k, v)| (k.clone(), ScheduledInstanceView::from(v)))
3302                .collect(),
3303            az_group_opt_in: state.az_group_opt_in.clone(),
3304            instance_status_reports: state
3305                .instance_status_reports
3306                .iter()
3307                .map(InstanceStatusReportView::from)
3308                .collect(),
3309            network_insights_access_scopes: state
3310                .network_insights_access_scopes
3311                .iter()
3312                .map(|(k, v)| (k.clone(), NetworkInsightsAccessScopeView::from(v)))
3313                .collect(),
3314            network_insights_access_scope_analyses: state
3315                .network_insights_access_scope_analyses
3316                .iter()
3317                .map(|(k, v)| (k.clone(), NetworkInsightsAccessScopeAnalysisView::from(v)))
3318                .collect(),
3319            network_insights_paths: state
3320                .network_insights_paths
3321                .iter()
3322                .map(|(k, v)| (k.clone(), NetworkInsightsPathView::from(v)))
3323                .collect(),
3324            network_insights_analyses: state
3325                .network_insights_analyses
3326                .iter()
3327                .map(|(k, v)| (k.clone(), NetworkInsightsAnalysisView::from(v)))
3328                .collect(),
3329            traffic_mirror_filters: state
3330                .traffic_mirror_filters
3331                .iter()
3332                .map(|(k, v)| (k.clone(), TrafficMirrorFilterView::from(v)))
3333                .collect(),
3334            traffic_mirror_sessions: state
3335                .traffic_mirror_sessions
3336                .iter()
3337                .map(|(k, v)| (k.clone(), TrafficMirrorSessionView::from(v)))
3338                .collect(),
3339            traffic_mirror_targets: state
3340                .traffic_mirror_targets
3341                .iter()
3342                .map(|(k, v)| (k.clone(), TrafficMirrorTargetView::from(v)))
3343                .collect(),
3344            client_vpn_endpoints: state
3345                .client_vpn_endpoints
3346                .iter()
3347                .map(|(k, v)| (k.clone(), ClientVpnEndpointView::from(v)))
3348                .collect(),
3349            client_vpn_target_network_associations: state
3350                .client_vpn_target_network_associations
3351                .iter()
3352                .map(|(k, v)| (k.clone(), ClientVpnTargetNetworkAssociationView::from(v)))
3353                .collect(),
3354            client_vpn_authorization_rules: state
3355                .client_vpn_authorization_rules
3356                .values()
3357                .map(ClientVpnAuthorizationRuleView::from)
3358                .collect(),
3359            client_vpn_routes: state
3360                .client_vpn_routes
3361                .values()
3362                .map(ClientVpnRouteView::from)
3363                .collect(),
3364            client_vpn_connections: state
3365                .client_vpn_connections
3366                .iter()
3367                .map(|(k, v)| (k.clone(), ClientVpnConnectionView::from(v)))
3368                .collect(),
3369            local_gateways: state
3370                .local_gateways
3371                .iter()
3372                .map(|(k, v)| (k.clone(), LocalGatewayView::from(v)))
3373                .collect(),
3374            local_gateway_route_tables: state
3375                .local_gateway_route_tables
3376                .iter()
3377                .map(|(k, v)| (k.clone(), LocalGatewayRouteTableView::from(v)))
3378                .collect(),
3379            local_gateway_routes: state
3380                .local_gateway_routes
3381                .values()
3382                .map(LocalGatewayRouteView::from)
3383                .collect(),
3384            local_gateway_route_table_virtual_interface_group_associations: state
3385                .local_gateway_route_table_virtual_interface_group_associations
3386                .iter()
3387                .map(|(k, v)| {
3388                    (
3389                        k.clone(),
3390                        LocalGatewayRouteTableVirtualInterfaceGroupAssociationView::from(v),
3391                    )
3392                })
3393                .collect(),
3394            local_gateway_route_table_vpc_associations: state
3395                .local_gateway_route_table_vpc_associations
3396                .iter()
3397                .map(|(k, v)| (k.clone(), LocalGatewayRouteTableVpcAssociationView::from(v)))
3398                .collect(),
3399            local_gateway_virtual_interfaces: state
3400                .local_gateway_virtual_interfaces
3401                .iter()
3402                .map(|(k, v)| (k.clone(), LocalGatewayVirtualInterfaceView::from(v)))
3403                .collect(),
3404            local_gateway_virtual_interface_groups: state
3405                .local_gateway_virtual_interface_groups
3406                .iter()
3407                .map(|(k, v)| (k.clone(), LocalGatewayVirtualInterfaceGroupView::from(v)))
3408                .collect(),
3409            route_servers: state
3410                .route_servers
3411                .iter()
3412                .map(|(k, v)| (k.clone(), RouteServerView::from(v)))
3413                .collect(),
3414            route_server_endpoints: state
3415                .route_server_endpoints
3416                .iter()
3417                .map(|(k, v)| (k.clone(), RouteServerEndpointView::from(v)))
3418                .collect(),
3419            route_server_peers: state
3420                .route_server_peers
3421                .iter()
3422                .map(|(k, v)| (k.clone(), RouteServerPeerView::from(v)))
3423                .collect(),
3424            route_server_associations: state
3425                .route_server_associations
3426                .values()
3427                .map(RouteServerAssociationView::from)
3428                .collect(),
3429            verified_access_instances: state
3430                .verified_access_instances
3431                .iter()
3432                .map(|(k, v)| (k.clone(), VerifiedAccessInstanceView::from(v)))
3433                .collect(),
3434            verified_access_trust_providers: state
3435                .verified_access_trust_providers
3436                .iter()
3437                .map(|(k, v)| (k.clone(), VerifiedAccessTrustProviderView::from(v)))
3438                .collect(),
3439            verified_access_groups: state
3440                .verified_access_groups
3441                .iter()
3442                .map(|(k, v)| (k.clone(), VerifiedAccessGroupView::from(v)))
3443                .collect(),
3444            verified_access_endpoints: state
3445                .verified_access_endpoints
3446                .iter()
3447                .map(|(k, v)| (k.clone(), VerifiedAccessEndpointView::from(v)))
3448                .collect(),
3449            verified_access_trust_provider_attachments: state
3450                .verified_access_trust_provider_attachments
3451                .values()
3452                .map(VerifiedAccessTrustProviderAttachmentView::from)
3453                .collect(),
3454            verified_access_instance_logging_configurations: state
3455                .verified_access_instance_logging_configurations
3456                .iter()
3457                .map(|(k, v)| (k.clone(), VerifiedAccessLogsView::from(v)))
3458                .collect(),
3459            billing_ownership_offers: state
3460                .billing_ownership_offers
3461                .values()
3462                .map(BillingOwnershipOfferView::from)
3463                .collect(),
3464            capacity_manager_data_exports: state
3465                .capacity_manager_data_exports
3466                .iter()
3467                .map(|(k, v)| (k.clone(), CapacityManagerDataExportView::from(v)))
3468                .collect(),
3469            interruptible_capacity_reservation_allocations: state
3470                .interruptible_capacity_reservation_allocations
3471                .iter()
3472                .map(|(k, v)| {
3473                    (
3474                        k.clone(),
3475                        InterruptibleCapacityReservationAllocationView::from(v),
3476                    )
3477                })
3478                .collect(),
3479            capacity_blocks: state
3480                .capacity_blocks
3481                .iter()
3482                .map(|(k, v)| (k.clone(), CapacityBlockView::from(v)))
3483                .collect(),
3484            capacity_block_extensions: state
3485                .capacity_block_extensions
3486                .iter()
3487                .map(|(k, v)| (k.clone(), CapacityBlockExtensionView::from(v)))
3488                .collect(),
3489            capacity_manager_organizations_access: state
3490                .capacity_manager_organizations_access
3491                .as_ref()
3492                .map(CapacityManagerOrganizationsAccessView::from),
3493            tgw_multicast_domains: state
3494                .tgw_multicast_domains
3495                .iter()
3496                .map(|(k, v)| (k.clone(), TransitGatewayMulticastDomainView::from(v)))
3497                .collect(),
3498            tgw_multicast_domain_associations: state
3499                .tgw_multicast_domain_associations
3500                .values()
3501                .map(TransitGatewayMulticastDomainAssociationView::from)
3502                .collect(),
3503            tgw_multicast_group_members: state
3504                .tgw_multicast_group_members
3505                .values()
3506                .map(TransitGatewayMulticastGroupMemberView::from)
3507                .collect(),
3508            tgw_multicast_group_sources: state
3509                .tgw_multicast_group_sources
3510                .values()
3511                .map(TransitGatewayMulticastGroupSourceView::from)
3512                .collect(),
3513            tgw_connects: state
3514                .tgw_connects
3515                .iter()
3516                .map(|(k, v)| (k.clone(), TransitGatewayConnectView::from(v)))
3517                .collect(),
3518            tgw_connect_peers: state
3519                .tgw_connect_peers
3520                .iter()
3521                .map(|(k, v)| (k.clone(), TransitGatewayConnectPeerView::from(v)))
3522                .collect(),
3523            tgw_metering_policies: state
3524                .tgw_metering_policies
3525                .iter()
3526                .map(|(k, v)| (k.clone(), TransitGatewayMeteringPolicyView::from(v)))
3527                .collect(),
3528            tgw_metering_policy_entries: state
3529                .tgw_metering_policy_entries
3530                .values()
3531                .map(TransitGatewayMeteringPolicyEntryView::from)
3532                .collect(),
3533            tgw_policy_tables: state
3534                .tgw_policy_tables
3535                .iter()
3536                .map(|(k, v)| (k.clone(), TransitGatewayPolicyTableView::from(v)))
3537                .collect(),
3538            tgw_policy_table_associations: state
3539                .tgw_policy_table_associations
3540                .values()
3541                .map(TransitGatewayPolicyTableAssociationView::from)
3542                .collect(),
3543            tgw_prefix_list_references: state
3544                .tgw_prefix_list_references
3545                .values()
3546                .map(TransitGatewayPrefixListReferenceView::from)
3547                .collect(),
3548            tgw_route_table_announcements: state
3549                .tgw_route_table_announcements
3550                .iter()
3551                .map(|(k, v)| (k.clone(), TransitGatewayRouteTableAnnouncementView::from(v)))
3552                .collect(),
3553            ipams: state
3554                .ipams
3555                .iter()
3556                .map(|(k, v)| (k.clone(), IpamView::from(v)))
3557                .collect(),
3558            ipam_scopes: state
3559                .ipam_scopes
3560                .iter()
3561                .map(|(k, v)| (k.clone(), IpamScopeView::from(v)))
3562                .collect(),
3563            ipam_pools: state
3564                .ipam_pools
3565                .iter()
3566                .map(|(k, v)| (k.clone(), IpamPoolView::from(v)))
3567                .collect(),
3568            ipam_pool_cidrs: state
3569                .ipam_pool_cidrs
3570                .iter()
3571                .map(|(k, v)| IpamPoolCidrView::from_kv(k, v))
3572                .collect(),
3573            ipam_pool_allocations: state
3574                .ipam_pool_allocations
3575                .values()
3576                .map(IpamPoolAllocationView::from)
3577                .collect(),
3578            ipam_resource_discoveries: state
3579                .ipam_resource_discoveries
3580                .iter()
3581                .map(|(k, v)| (k.clone(), IpamResourceDiscoveryView::from(v)))
3582                .collect(),
3583            ipam_resource_discovery_associations: state
3584                .ipam_resource_discovery_associations
3585                .iter()
3586                .map(|(k, v)| (k.clone(), IpamResourceDiscoveryAssociationView::from(v)))
3587                .collect(),
3588            ipam_byoasns: state
3589                .ipam_byoasns
3590                .values()
3591                .map(IpamByoasnView::from)
3592                .collect(),
3593            ipam_external_resource_verification_tokens: state
3594                .ipam_external_resource_verification_tokens
3595                .iter()
3596                .map(|(k, v)| {
3597                    (
3598                        k.clone(),
3599                        IpamExternalResourceVerificationTokenView::from(v),
3600                    )
3601                })
3602                .collect(),
3603            ipam_policies: state
3604                .ipam_policies
3605                .iter()
3606                .map(|(k, v)| (k.clone(), IpamPolicyView::from(v)))
3607                .collect(),
3608            ipam_prefix_list_resolvers: state
3609                .ipam_prefix_list_resolvers
3610                .iter()
3611                .map(|(k, v)| (k.clone(), IpamPrefixListResolverView::from(v)))
3612                .collect(),
3613            ipam_prefix_list_resolver_targets: state
3614                .ipam_prefix_list_resolver_targets
3615                .values()
3616                .map(IpamPrefixListResolverTargetView::from)
3617                .collect(),
3618            volume_modifications: state
3619                .volume_modifications
3620                .iter()
3621                .map(|(k, v)| (k.clone(), VolumeModificationView::from(v)))
3622                .collect(),
3623            import_volume_tasks: state
3624                .import_volume_tasks
3625                .iter()
3626                .map(|(k, v)| (k.clone(), ImportVolumeTaskView::from(v)))
3627                .collect(),
3628            bundle_tasks: state
3629                .bundle_tasks
3630                .iter()
3631                .map(|(k, v)| (k.clone(), BundleTaskView::from(v)))
3632                .collect(),
3633            id_format: state
3634                .id_format
3635                .iter()
3636                .map(|(k, v)| (k.clone(), IdFormatEntryView::from(v)))
3637                .collect(),
3638            outpost_lags: state
3639                .outpost_lags
3640                .iter()
3641                .map(|(k, v)| (k.clone(), OutpostLagView::from(v)))
3642                .collect(),
3643            export_image_tasks: state
3644                .export_image_tasks
3645                .iter()
3646                .map(|(k, v)| (k.clone(), ExportImageTaskView::from(v)))
3647                .collect(),
3648            ebs_default_kms_key_id: state.ebs_default_kms_key_id.clone(),
3649            serial_console_access_enabled: state.serial_console_access_enabled,
3650            allowed_images_settings_state: state.allowed_images_settings_state.clone(),
3651            image_block_public_access_state: state.image_block_public_access_state.clone(),
3652            aws_network_performance_subscriptions: state
3653                .aws_network_performance_subscriptions
3654                .values()
3655                .map(|s| AwsNetworkPerformanceSubscriptionView {
3656                    source: s.source.clone(),
3657                    destination: s.destination.clone(),
3658                    metric: s.metric.clone(),
3659                    statistic: s.statistic.clone(),
3660                    period: s.period.clone(),
3661                })
3662                .collect(),
3663            counters: CountersView::from(&state.counters),
3664        }
3665    }
3666}
3667
3668impl From<&crate::state::Ec2Counters> for CountersView {
3669    fn from(c: &crate::state::Ec2Counters) -> Self {
3670        CountersView {
3671            vpc: c.vpc,
3672            subnet: c.subnet,
3673            igw: c.igw,
3674            sg: c.sg,
3675            sgr: c.sgr,
3676            rtb: c.rtb,
3677            rtbassoc: c.rtbassoc,
3678            keypair: c.keypair,
3679            nacl: c.nacl,
3680            nacl_assoc: c.nacl_assoc,
3681            eip: c.eip,
3682            eip_assoc: c.eip_assoc,
3683            nat: c.nat,
3684            dopt: c.dopt,
3685            eigw: c.eigw,
3686            flow_log: c.flow_log,
3687            vpc_peering: c.vpc_peering,
3688            vpc_endpoint: c.vpc_endpoint,
3689            prefix_list: c.prefix_list,
3690            cgw: c.cgw,
3691            vgw: c.vgw,
3692            vpn: c.vpn,
3693            cgw_carrier: c.cgw_carrier,
3694            eni: c.eni,
3695            eni_attach: c.eni_attach,
3696            vpc_cidr_assoc: c.vpc_cidr_assoc,
3697            tgw: c.tgw,
3698            tgw_attach: c.tgw_attach,
3699            tgw_rtb: c.tgw_rtb,
3700            instance: c.instance,
3701            vol: c.vol,
3702            snapshot: c.snapshot,
3703            ami: c.ami,
3704            lt: c.lt,
3705            spot: c.spot,
3706            iam_assoc: c.iam_assoc,
3707            host: c.host,
3708            fleet: c.fleet,
3709            vpce_svc: c.vpce_svc,
3710            spot_fleet: c.spot_fleet,
3711            subnet_cidr_res: c.subnet_cidr_res,
3712            subnet_ipv6_assoc: c.subnet_ipv6_assoc,
3713            placement_group: c.placement_group,
3714            eni_permission: c.eni_permission,
3715            instance_connect_endpoint: c.instance_connect_endpoint,
3716            capacity_reservation: c.capacity_reservation,
3717            capacity_reservation_fleet: c.capacity_reservation_fleet,
3718            coip_pool: c.coip_pool,
3719            mac_sip_task: c.mac_sip_task,
3720            declarative_policies_report: c.declarative_policies_report,
3721            public_ipv4_pool: c.public_ipv4_pool,
3722            address_transfer: c.address_transfer,
3723            nat_gateway_address_assoc: c.nat_gateway_address_assoc,
3724            vpn_concentrator: c.vpn_concentrator,
3725            vpc_endpoint_connection_notification: c.vpc_endpoint_connection_notification,
3726            vpc_block_public_access_exclusion: c.vpc_block_public_access_exclusion,
3727            vpc_encryption_control: c.vpc_encryption_control,
3728            mac_volume_ownership_task: c.mac_volume_ownership_task,
3729            replace_root_volume_task: c.replace_root_volume_task,
3730            snapshot_import_task: c.snapshot_import_task,
3731            conversion_task: c.conversion_task,
3732            export_task: c.export_task,
3733            import_task: c.import_task,
3734            trunk_interface_assoc: c.trunk_interface_assoc,
3735            secondary_network: c.secondary_network,
3736            secondary_subnet: c.secondary_subnet,
3737            reserved_instances_exchange: c.reserved_instances_exchange,
3738            reserved_instances_listing: c.reserved_instances_listing,
3739            reserved_instances_purchase: c.reserved_instances_purchase,
3740            reserved_instances: c.reserved_instances,
3741            reserved_instances_modification: c.reserved_instances_modification,
3742            fpga_image: c.fpga_image,
3743            image_usage_report: c.image_usage_report,
3744            import_image_task: c.import_image_task,
3745            instance_event_window: c.instance_event_window,
3746            instance_event: c.instance_event,
3747            host_reservation: c.host_reservation,
3748            scheduled_instance: c.scheduled_instance,
3749            network_insights_access_scope: c.network_insights_access_scope,
3750            network_insights_access_scope_analysis: c.network_insights_access_scope_analysis,
3751            network_insights_path: c.network_insights_path,
3752            network_insights_analysis: c.network_insights_analysis,
3753            traffic_mirror_filter: c.traffic_mirror_filter,
3754            traffic_mirror_filter_rule: c.traffic_mirror_filter_rule,
3755            traffic_mirror_session: c.traffic_mirror_session,
3756            traffic_mirror_target: c.traffic_mirror_target,
3757            client_vpn_endpoint: c.client_vpn_endpoint,
3758            client_vpn_target_network_association: c.client_vpn_target_network_association,
3759            client_vpn_connection: c.client_vpn_connection,
3760            local_gateway: c.local_gateway,
3761            local_gateway_route_table: c.local_gateway_route_table,
3762            local_gateway_route_table_virtual_interface_group_association: c
3763                .local_gateway_route_table_virtual_interface_group_association,
3764            local_gateway_route_table_vpc_association: c.local_gateway_route_table_vpc_association,
3765            local_gateway_virtual_interface: c.local_gateway_virtual_interface,
3766            local_gateway_virtual_interface_group: c.local_gateway_virtual_interface_group,
3767            route_server: c.route_server,
3768            route_server_endpoint: c.route_server_endpoint,
3769            route_server_peer: c.route_server_peer,
3770            verified_access_instance: c.verified_access_instance,
3771            verified_access_trust_provider: c.verified_access_trust_provider,
3772            verified_access_group: c.verified_access_group,
3773            verified_access_endpoint: c.verified_access_endpoint,
3774            capacity_manager_data_export: c.capacity_manager_data_export,
3775            interruptible_capacity_reservation_allocation: c
3776                .interruptible_capacity_reservation_allocation,
3777            capacity_block: c.capacity_block,
3778            capacity_block_extension: c.capacity_block_extension,
3779            tgw_multicast_domain: c.tgw_multicast_domain,
3780            tgw_connect: c.tgw_connect,
3781            tgw_connect_peer: c.tgw_connect_peer,
3782            tgw_metering_policy: c.tgw_metering_policy,
3783            tgw_metering_policy_entry: c.tgw_metering_policy_entry,
3784            tgw_policy_table: c.tgw_policy_table,
3785            tgw_route_table_announcement: c.tgw_route_table_announcement,
3786            ipam: c.ipam,
3787            ipam_scope: c.ipam_scope,
3788            ipam_pool: c.ipam_pool,
3789            ipam_pool_cidr: c.ipam_pool_cidr,
3790            ipam_pool_allocation: c.ipam_pool_allocation,
3791            ipam_resource_discovery: c.ipam_resource_discovery,
3792            ipam_resource_discovery_association: c.ipam_resource_discovery_association,
3793            ipam_external_resource_verification_token: c.ipam_external_resource_verification_token,
3794            ipam_policy: c.ipam_policy,
3795            ipam_prefix_list_resolver: c.ipam_prefix_list_resolver,
3796            ipam_prefix_list_resolver_target: c.ipam_prefix_list_resolver_target,
3797            bundle_task: c.bundle_task,
3798            volume_modification: c.volume_modification,
3799            import_volume_task: c.import_volume_task,
3800            export_image_task: c.export_image_task,
3801            outpost_lag: c.outpost_lag,
3802        }
3803    }
3804}
3805
3806impl From<CountersView> for crate::state::Ec2Counters {
3807    fn from(c: CountersView) -> Self {
3808        crate::state::Ec2Counters {
3809            vpc: c.vpc,
3810            subnet: c.subnet,
3811            igw: c.igw,
3812            sg: c.sg,
3813            sgr: c.sgr,
3814            rtb: c.rtb,
3815            rtbassoc: c.rtbassoc,
3816            keypair: c.keypair,
3817            nacl: c.nacl,
3818            nacl_assoc: c.nacl_assoc,
3819            eip: c.eip,
3820            eip_assoc: c.eip_assoc,
3821            nat: c.nat,
3822            dopt: c.dopt,
3823            eigw: c.eigw,
3824            flow_log: c.flow_log,
3825            vpc_peering: c.vpc_peering,
3826            vpc_endpoint: c.vpc_endpoint,
3827            prefix_list: c.prefix_list,
3828            cgw: c.cgw,
3829            vgw: c.vgw,
3830            vpn: c.vpn,
3831            cgw_carrier: c.cgw_carrier,
3832            eni: c.eni,
3833            eni_attach: c.eni_attach,
3834            vpc_cidr_assoc: c.vpc_cidr_assoc,
3835            tgw: c.tgw,
3836            tgw_attach: c.tgw_attach,
3837            tgw_rtb: c.tgw_rtb,
3838            instance: c.instance,
3839            vol: c.vol,
3840            snapshot: c.snapshot,
3841            ami: c.ami,
3842            lt: c.lt,
3843            spot: c.spot,
3844            iam_assoc: c.iam_assoc,
3845            host: c.host,
3846            fleet: c.fleet,
3847            vpce_svc: c.vpce_svc,
3848            spot_fleet: c.spot_fleet,
3849            subnet_cidr_res: c.subnet_cidr_res,
3850            subnet_ipv6_assoc: c.subnet_ipv6_assoc,
3851            placement_group: c.placement_group,
3852            eni_permission: c.eni_permission,
3853            instance_connect_endpoint: c.instance_connect_endpoint,
3854            capacity_reservation: c.capacity_reservation,
3855            capacity_reservation_fleet: c.capacity_reservation_fleet,
3856            coip_pool: c.coip_pool,
3857            mac_sip_task: c.mac_sip_task,
3858            declarative_policies_report: c.declarative_policies_report,
3859            public_ipv4_pool: c.public_ipv4_pool,
3860            address_transfer: c.address_transfer,
3861            nat_gateway_address_assoc: c.nat_gateway_address_assoc,
3862            vpn_concentrator: c.vpn_concentrator,
3863            vpc_endpoint_connection_notification: c.vpc_endpoint_connection_notification,
3864            vpc_block_public_access_exclusion: c.vpc_block_public_access_exclusion,
3865            vpc_encryption_control: c.vpc_encryption_control,
3866            mac_volume_ownership_task: c.mac_volume_ownership_task,
3867            replace_root_volume_task: c.replace_root_volume_task,
3868            snapshot_import_task: c.snapshot_import_task,
3869            conversion_task: c.conversion_task,
3870            export_task: c.export_task,
3871            import_task: c.import_task,
3872            trunk_interface_assoc: c.trunk_interface_assoc,
3873            secondary_network: c.secondary_network,
3874            secondary_subnet: c.secondary_subnet,
3875            reserved_instances_exchange: c.reserved_instances_exchange,
3876            reserved_instances_listing: c.reserved_instances_listing,
3877            reserved_instances_purchase: c.reserved_instances_purchase,
3878            reserved_instances: c.reserved_instances,
3879            reserved_instances_modification: c.reserved_instances_modification,
3880            fpga_image: c.fpga_image,
3881            image_usage_report: c.image_usage_report,
3882            import_image_task: c.import_image_task,
3883            instance_event_window: c.instance_event_window,
3884            instance_event: c.instance_event,
3885            host_reservation: c.host_reservation,
3886            scheduled_instance: c.scheduled_instance,
3887            network_insights_access_scope: c.network_insights_access_scope,
3888            network_insights_access_scope_analysis: c.network_insights_access_scope_analysis,
3889            network_insights_path: c.network_insights_path,
3890            network_insights_analysis: c.network_insights_analysis,
3891            traffic_mirror_filter: c.traffic_mirror_filter,
3892            traffic_mirror_filter_rule: c.traffic_mirror_filter_rule,
3893            traffic_mirror_session: c.traffic_mirror_session,
3894            traffic_mirror_target: c.traffic_mirror_target,
3895            client_vpn_endpoint: c.client_vpn_endpoint,
3896            client_vpn_target_network_association: c.client_vpn_target_network_association,
3897            client_vpn_connection: c.client_vpn_connection,
3898            local_gateway: c.local_gateway,
3899            local_gateway_route_table: c.local_gateway_route_table,
3900            local_gateway_route_table_virtual_interface_group_association: c
3901                .local_gateway_route_table_virtual_interface_group_association,
3902            local_gateway_route_table_vpc_association: c.local_gateway_route_table_vpc_association,
3903            local_gateway_virtual_interface: c.local_gateway_virtual_interface,
3904            local_gateway_virtual_interface_group: c.local_gateway_virtual_interface_group,
3905            route_server: c.route_server,
3906            route_server_endpoint: c.route_server_endpoint,
3907            route_server_peer: c.route_server_peer,
3908            verified_access_instance: c.verified_access_instance,
3909            verified_access_trust_provider: c.verified_access_trust_provider,
3910            verified_access_group: c.verified_access_group,
3911            verified_access_endpoint: c.verified_access_endpoint,
3912            capacity_manager_data_export: c.capacity_manager_data_export,
3913            interruptible_capacity_reservation_allocation: c
3914                .interruptible_capacity_reservation_allocation,
3915            capacity_block: c.capacity_block,
3916            capacity_block_extension: c.capacity_block_extension,
3917            tgw_multicast_domain: c.tgw_multicast_domain,
3918            tgw_connect: c.tgw_connect,
3919            tgw_connect_peer: c.tgw_connect_peer,
3920            tgw_metering_policy: c.tgw_metering_policy,
3921            tgw_metering_policy_entry: c.tgw_metering_policy_entry,
3922            tgw_policy_table: c.tgw_policy_table,
3923            tgw_route_table_announcement: c.tgw_route_table_announcement,
3924            ipam: c.ipam,
3925            ipam_scope: c.ipam_scope,
3926            ipam_pool: c.ipam_pool,
3927            ipam_pool_cidr: c.ipam_pool_cidr,
3928            ipam_pool_allocation: c.ipam_pool_allocation,
3929            ipam_resource_discovery: c.ipam_resource_discovery,
3930            ipam_resource_discovery_association: c.ipam_resource_discovery_association,
3931            ipam_external_resource_verification_token: c.ipam_external_resource_verification_token,
3932            ipam_policy: c.ipam_policy,
3933            ipam_prefix_list_resolver: c.ipam_prefix_list_resolver,
3934            ipam_prefix_list_resolver_target: c.ipam_prefix_list_resolver_target,
3935            bundle_task: c.bundle_task,
3936            volume_modification: c.volume_modification,
3937            import_volume_task: c.import_volume_task,
3938            export_image_task: c.export_image_task,
3939            outpost_lag: c.outpost_lag,
3940        }
3941    }
3942}
3943
3944impl From<&Vpc> for VpcView {
3945    fn from(v: &Vpc) -> Self {
3946        VpcView {
3947            vpc_id: v.vpc_id.clone(),
3948            cidr_block: v.cidr_block.clone(),
3949            state: v.state.clone(),
3950            dhcp_options_id: v.dhcp_options_id.clone(),
3951            instance_tenancy: v.instance_tenancy.clone(),
3952            is_default: v.is_default,
3953            enable_dns_hostnames: v.enable_dns_hostnames,
3954            enable_dns_support: v.enable_dns_support,
3955            secondary_cidr_blocks: v.secondary_cidr_blocks.clone(),
3956            tags: v.tags.clone(),
3957            classic_link_enabled: v.classic_link_enabled,
3958        }
3959    }
3960}
3961
3962impl From<&Subnet> for SubnetView {
3963    fn from(s: &Subnet) -> Self {
3964        SubnetView {
3965            subnet_id: s.subnet_id.clone(),
3966            vpc_id: s.vpc_id.clone(),
3967            cidr_block: s.cidr_block.clone(),
3968            availability_zone: s.availability_zone.clone(),
3969            state: s.state.clone(),
3970            available_ip_address_count: s.available_ip_address_count,
3971            map_public_ip_on_launch: s.map_public_ip_on_launch,
3972            ipv6_cidr_blocks: s
3973                .ipv6_cidr_blocks
3974                .iter()
3975                .map(SubnetIpv6CidrAssocView::from)
3976                .collect(),
3977            tags: s.tags.clone(),
3978        }
3979    }
3980}
3981
3982impl From<&SubnetIpv6CidrAssoc> for SubnetIpv6CidrAssocView {
3983    fn from(a: &SubnetIpv6CidrAssoc) -> Self {
3984        SubnetIpv6CidrAssocView {
3985            association_id: a.association_id.clone(),
3986            ipv6_cidr_block: a.ipv6_cidr_block.clone(),
3987            state: a.state.clone(),
3988        }
3989    }
3990}
3991
3992impl From<&InternetGateway> for InternetGatewayView {
3993    fn from(igw: &InternetGateway) -> Self {
3994        InternetGatewayView {
3995            igw_id: igw.igw_id.clone(),
3996            attachments: igw
3997                .attachments
3998                .iter()
3999                .map(IgwAttachmentView::from)
4000                .collect(),
4001            tags: igw.tags.clone(),
4002        }
4003    }
4004}
4005
4006impl From<&IgwAttachment> for IgwAttachmentView {
4007    fn from(a: &IgwAttachment) -> Self {
4008        IgwAttachmentView {
4009            vpc_id: a.vpc_id.clone(),
4010            state: a.state.clone(),
4011        }
4012    }
4013}
4014
4015impl From<&SecurityGroup> for SecurityGroupView {
4016    fn from(sg: &SecurityGroup) -> Self {
4017        SecurityGroupView {
4018            group_id: sg.group_id.clone(),
4019            group_name: sg.group_name.clone(),
4020            description: sg.description.clone(),
4021            vpc_id: sg.vpc_id.clone(),
4022            owner_id: sg.owner_id.clone(),
4023            ingress_rules: sg
4024                .ingress_rules
4025                .iter()
4026                .map(IpPermissionView::from)
4027                .collect(),
4028            egress_rules: sg.egress_rules.iter().map(IpPermissionView::from).collect(),
4029            tags: sg.tags.clone(),
4030        }
4031    }
4032}
4033
4034impl From<&IpPermission> for IpPermissionView {
4035    fn from(p: &IpPermission) -> Self {
4036        IpPermissionView {
4037            from_port: p.from_port,
4038            to_port: p.to_port,
4039            ip_protocol: p.ip_protocol.clone(),
4040            ip_ranges: p.ip_ranges.iter().map(IpRangeView::from).collect(),
4041            ipv6_ranges: p.ipv6_ranges.iter().map(Ipv6RangeView::from).collect(),
4042            user_id_group_pairs: p
4043                .user_id_group_pairs
4044                .iter()
4045                .map(UserIdGroupPairView::from)
4046                .collect(),
4047        }
4048    }
4049}
4050
4051impl From<&IpRange> for IpRangeView {
4052    fn from(r: &IpRange) -> Self {
4053        IpRangeView {
4054            cidr_ip: r.cidr_ip.clone(),
4055            description: r.description.clone(),
4056        }
4057    }
4058}
4059
4060impl From<&Ipv6Range> for Ipv6RangeView {
4061    fn from(r: &Ipv6Range) -> Self {
4062        Ipv6RangeView {
4063            cidr_ipv6: r.cidr_ipv6.clone(),
4064            description: r.description.clone(),
4065        }
4066    }
4067}
4068
4069impl From<&UserIdGroupPair> for UserIdGroupPairView {
4070    fn from(p: &UserIdGroupPair) -> Self {
4071        UserIdGroupPairView {
4072            group_id: p.group_id.clone(),
4073            user_id: p.user_id.clone(),
4074        }
4075    }
4076}
4077
4078impl From<&RouteTable> for RouteTableView {
4079    fn from(rtb: &RouteTable) -> Self {
4080        RouteTableView {
4081            route_table_id: rtb.route_table_id.clone(),
4082            vpc_id: rtb.vpc_id.clone(),
4083            routes: rtb.routes.iter().map(RouteView::from).collect(),
4084            associations: rtb
4085                .associations
4086                .iter()
4087                .map(RouteTableAssociationView::from)
4088                .collect(),
4089            propagating_vgws: rtb.propagating_vgws.clone(),
4090            tags: rtb.tags.clone(),
4091        }
4092    }
4093}
4094
4095impl From<&Route> for RouteView {
4096    fn from(r: &Route) -> Self {
4097        RouteView {
4098            destination_cidr_block: r.destination_cidr_block.clone(),
4099            destination_ipv6_cidr_block: r.destination_ipv6_cidr_block.clone(),
4100            gateway_id: r.gateway_id.clone(),
4101            state: r.state.clone(),
4102            origin: r.origin.clone(),
4103        }
4104    }
4105}
4106
4107impl From<&RouteTableAssociation> for RouteTableAssociationView {
4108    fn from(a: &RouteTableAssociation) -> Self {
4109        RouteTableAssociationView {
4110            association_id: a.association_id.clone(),
4111            subnet_id: a.subnet_id.clone(),
4112            gateway_id: a.gateway_id.clone(),
4113            main: a.main,
4114            state: a.state.clone(),
4115        }
4116    }
4117}
4118
4119impl From<&KeyPair> for KeyPairView {
4120    fn from(kp: &KeyPair) -> Self {
4121        KeyPairView {
4122            key_pair_id: kp.key_pair_id.clone(),
4123            key_name: kp.key_name.clone(),
4124            fingerprint: kp.fingerprint.clone(),
4125            tags: kp.tags.clone(),
4126        }
4127    }
4128}
4129
4130impl From<&NetworkAcl> for NetworkAclView {
4131    fn from(n: &NetworkAcl) -> Self {
4132        NetworkAclView {
4133            network_acl_id: n.network_acl_id.clone(),
4134            vpc_id: n.vpc_id.clone(),
4135            is_default: n.is_default,
4136            entries: n.entries.iter().map(NetworkAclEntryView::from).collect(),
4137            associations: n
4138                .associations
4139                .iter()
4140                .map(NetworkAclAssociationView::from)
4141                .collect(),
4142            tags: n.tags.clone(),
4143        }
4144    }
4145}
4146
4147impl From<&NetworkAclEntry> for NetworkAclEntryView {
4148    fn from(e: &NetworkAclEntry) -> Self {
4149        NetworkAclEntryView {
4150            rule_number: e.rule_number,
4151            protocol: e.protocol.clone(),
4152            rule_action: e.rule_action.clone(),
4153            egress: e.egress,
4154            cidr_block: e.cidr_block.clone(),
4155            ipv6_cidr_block: e.ipv6_cidr_block.clone(),
4156            port_range: e.port_range.as_ref().map(PortRangeView::from),
4157            icmp_type_code: e.icmp_type_code.as_ref().map(IcmpTypeCodeView::from),
4158        }
4159    }
4160}
4161
4162impl From<&PortRange> for PortRangeView {
4163    fn from(p: &PortRange) -> Self {
4164        PortRangeView {
4165            from: p.from,
4166            to: p.to,
4167        }
4168    }
4169}
4170
4171impl From<&IcmpTypeCode> for IcmpTypeCodeView {
4172    fn from(i: &IcmpTypeCode) -> Self {
4173        IcmpTypeCodeView {
4174            type_num: i.type_num,
4175            code: i.code,
4176        }
4177    }
4178}
4179
4180impl From<&NetworkAclAssociation> for NetworkAclAssociationView {
4181    fn from(a: &NetworkAclAssociation) -> Self {
4182        NetworkAclAssociationView {
4183            network_acl_association_id: a.network_acl_association_id.clone(),
4184            network_acl_id: a.network_acl_id.clone(),
4185            subnet_id: a.subnet_id.clone(),
4186        }
4187    }
4188}
4189
4190impl From<&ElasticIp> for ElasticIpView {
4191    fn from(e: &ElasticIp) -> Self {
4192        ElasticIpView {
4193            allocation_id: e.allocation_id.clone(),
4194            public_ip: e.public_ip.clone(),
4195            association_id: e.association_id.clone(),
4196            instance_id: e.instance_id.clone(),
4197            network_interface_id: e.network_interface_id.clone(),
4198            private_ip_address: e.private_ip_address.clone(),
4199            address_attribute_ptr_record: e.address_attribute_ptr_record.clone(),
4200            domain: e.domain.clone(),
4201            pending_transfer: e.pending_transfer.clone(),
4202            tags: e.tags.clone(),
4203        }
4204    }
4205}
4206
4207impl From<&NatGateway> for NatGatewayView {
4208    fn from(n: &NatGateway) -> Self {
4209        NatGatewayView {
4210            nat_gateway_id: n.nat_gateway_id.clone(),
4211            vpc_id: n.vpc_id.clone(),
4212            subnet_id: n.subnet_id.clone(),
4213            state: n.state.clone(),
4214            connectivity_type: n.connectivity_type.clone(),
4215            allocation_id: n.allocation_id.clone(),
4216            public_ip: n.public_ip.clone(),
4217            secondary_addresses: n
4218                .secondary_addresses
4219                .iter()
4220                .map(NatGatewayAddressAssociationView::from)
4221                .collect(),
4222            tags: n.tags.clone(),
4223        }
4224    }
4225}
4226
4227impl From<&NatGatewayAddressAssociation> for NatGatewayAddressAssociationView {
4228    fn from(a: &NatGatewayAddressAssociation) -> Self {
4229        NatGatewayAddressAssociationView {
4230            allocation_id: a.allocation_id.clone(),
4231            association_id: a.association_id.clone(),
4232            network_interface_id: a.network_interface_id.clone(),
4233            private_ip: a.private_ip.clone(),
4234            public_ip: a.public_ip.clone(),
4235            status: a.status.clone(),
4236            is_primary: a.is_primary,
4237        }
4238    }
4239}
4240
4241impl From<NatGatewayAddressAssociationView> for NatGatewayAddressAssociation {
4242    fn from(v: NatGatewayAddressAssociationView) -> Self {
4243        NatGatewayAddressAssociation {
4244            allocation_id: v.allocation_id,
4245            association_id: v.association_id,
4246            network_interface_id: v.network_interface_id,
4247            private_ip: v.private_ip,
4248            public_ip: v.public_ip,
4249            status: v.status,
4250            is_primary: v.is_primary,
4251        }
4252    }
4253}
4254
4255impl From<&ByoipCidr> for ByoipCidrView {
4256    fn from(b: &ByoipCidr) -> Self {
4257        ByoipCidrView {
4258            cidr: b.cidr.clone(),
4259            description: b.description.clone(),
4260            state: b.state.clone(),
4261            asn_association: b.asn_association.as_ref().map(AsnAssociationView::from),
4262            ipam_pool_id: b.ipam_pool_id.clone(),
4263        }
4264    }
4265}
4266
4267impl From<ByoipCidrView> for ByoipCidr {
4268    fn from(v: ByoipCidrView) -> Self {
4269        ByoipCidr {
4270            cidr: v.cidr,
4271            description: v.description,
4272            state: v.state,
4273            asn_association: v.asn_association.map(AsnAssociation::from),
4274            ipam_pool_id: v.ipam_pool_id,
4275        }
4276    }
4277}
4278
4279impl From<&AsnAssociation> for AsnAssociationView {
4280    fn from(a: &AsnAssociation) -> Self {
4281        AsnAssociationView {
4282            asn: a.asn.clone(),
4283            cidr: a.cidr.clone(),
4284            state: a.state.clone(),
4285            status_message: a.status_message.clone(),
4286        }
4287    }
4288}
4289
4290impl From<AsnAssociationView> for AsnAssociation {
4291    fn from(v: AsnAssociationView) -> Self {
4292        AsnAssociation {
4293            asn: v.asn,
4294            cidr: v.cidr,
4295            state: v.state,
4296            status_message: v.status_message,
4297        }
4298    }
4299}
4300
4301impl From<&PublicIpv4Pool> for PublicIpv4PoolView {
4302    fn from(p: &PublicIpv4Pool) -> Self {
4303        PublicIpv4PoolView {
4304            pool_id: p.pool_id.clone(),
4305            description: p.description.clone(),
4306            network_border_group: p.network_border_group.clone(),
4307            total_address_count: p.total_address_count,
4308            total_available_address_count: p.total_available_address_count,
4309            pool_address_ranges: p
4310                .pool_address_ranges
4311                .iter()
4312                .map(PublicIpv4PoolRangeView::from)
4313                .collect(),
4314            tags: p.tags.clone(),
4315        }
4316    }
4317}
4318
4319impl From<PublicIpv4PoolView> for PublicIpv4Pool {
4320    fn from(v: PublicIpv4PoolView) -> Self {
4321        PublicIpv4Pool {
4322            pool_id: v.pool_id,
4323            description: v.description,
4324            network_border_group: v.network_border_group,
4325            total_address_count: v.total_address_count,
4326            total_available_address_count: v.total_available_address_count,
4327            pool_address_ranges: v
4328                .pool_address_ranges
4329                .into_iter()
4330                .map(PublicIpv4PoolRange::from)
4331                .collect(),
4332            tags: v.tags,
4333        }
4334    }
4335}
4336
4337impl From<&PublicIpv4PoolRange> for PublicIpv4PoolRangeView {
4338    fn from(r: &PublicIpv4PoolRange) -> Self {
4339        PublicIpv4PoolRangeView {
4340            first_address: r.first_address.clone(),
4341            last_address: r.last_address.clone(),
4342            address_count: r.address_count,
4343            available_address_count: r.available_address_count,
4344        }
4345    }
4346}
4347
4348impl From<PublicIpv4PoolRangeView> for PublicIpv4PoolRange {
4349    fn from(v: PublicIpv4PoolRangeView) -> Self {
4350        PublicIpv4PoolRange {
4351            first_address: v.first_address,
4352            last_address: v.last_address,
4353            address_count: v.address_count,
4354            available_address_count: v.available_address_count,
4355        }
4356    }
4357}
4358
4359impl From<&CoipCidr> for CoipCidrView {
4360    fn from(c: &CoipCidr) -> Self {
4361        CoipCidrView {
4362            cidr: c.cidr.clone(),
4363            coip_pool_id: c.coip_pool_id.clone(),
4364        }
4365    }
4366}
4367
4368impl From<CoipCidrView> for CoipCidr {
4369    fn from(v: CoipCidrView) -> Self {
4370        CoipCidr {
4371            cidr: v.cidr,
4372            coip_pool_id: v.coip_pool_id,
4373        }
4374    }
4375}
4376
4377impl From<&AddressTransfer> for AddressTransferView {
4378    fn from(a: &AddressTransfer) -> Self {
4379        AddressTransferView {
4380            allocation_id: a.allocation_id.clone(),
4381            public_ip: a.public_ip.clone(),
4382            transfer_account_id: a.transfer_account_id.clone(),
4383            transfer_offer_expiration_timestamp: a.transfer_offer_expiration_timestamp.clone(),
4384            transfer_offer_accepted_timestamp: a.transfer_offer_accepted_timestamp.clone(),
4385            address_transfer_status: a.address_transfer_status.clone(),
4386        }
4387    }
4388}
4389
4390impl From<AddressTransferView> for AddressTransfer {
4391    fn from(v: AddressTransferView) -> Self {
4392        AddressTransfer {
4393            allocation_id: v.allocation_id,
4394            public_ip: v.public_ip,
4395            transfer_account_id: v.transfer_account_id,
4396            transfer_offer_expiration_timestamp: v.transfer_offer_expiration_timestamp,
4397            transfer_offer_accepted_timestamp: v.transfer_offer_accepted_timestamp,
4398            address_transfer_status: v.address_transfer_status,
4399        }
4400    }
4401}
4402
4403impl From<&DhcpOptions> for DhcpOptionsView {
4404    fn from(d: &DhcpOptions) -> Self {
4405        DhcpOptionsView {
4406            dhcp_options_id: d.dhcp_options_id.clone(),
4407            configurations: d
4408                .configurations
4409                .iter()
4410                .map(DhcpConfigurationView::from)
4411                .collect(),
4412            tags: d.tags.clone(),
4413        }
4414    }
4415}
4416
4417impl From<&DhcpConfiguration> for DhcpConfigurationView {
4418    fn from(c: &DhcpConfiguration) -> Self {
4419        DhcpConfigurationView {
4420            key: c.key.clone(),
4421            values: c.values.clone(),
4422        }
4423    }
4424}
4425
4426impl From<&EgressOnlyInternetGateway> for EgressOnlyIgwView {
4427    fn from(e: &EgressOnlyInternetGateway) -> Self {
4428        EgressOnlyIgwView {
4429            eigw_id: e.eigw_id.clone(),
4430            state: e.state.clone(),
4431            attachments: e
4432                .attachments
4433                .iter()
4434                .map(EoigwAttachmentView::from)
4435                .collect(),
4436            tags: e.tags.clone(),
4437        }
4438    }
4439}
4440
4441impl From<&EoigwAttachment> for EoigwAttachmentView {
4442    fn from(a: &EoigwAttachment) -> Self {
4443        EoigwAttachmentView {
4444            vpc_id: a.vpc_id.clone(),
4445            state: a.state.clone(),
4446        }
4447    }
4448}
4449
4450impl From<&FlowLog> for FlowLogView {
4451    fn from(f: &FlowLog) -> Self {
4452        FlowLogView {
4453            flow_log_id: f.flow_log_id.clone(),
4454            resource_id: f.resource_id.clone(),
4455            traffic_type: f.traffic_type.clone(),
4456            log_destination_type: f.log_destination_type.clone(),
4457            log_destination: f.log_destination.clone(),
4458            log_group_name: f.log_group_name.clone(),
4459            deliver_logs_status: f.deliver_logs_status.clone(),
4460            flow_log_status: f.flow_log_status.clone(),
4461            tags: f.tags.clone(),
4462        }
4463    }
4464}
4465
4466impl From<&VpcPeeringConnection> for VpcPeeringConnectionView {
4467    fn from(p: &VpcPeeringConnection) -> Self {
4468        VpcPeeringConnectionView {
4469            peering_id: p.peering_id.clone(),
4470            requester_vpc_id: p.requester_vpc_id.clone(),
4471            accepter_vpc_id: p.accepter_vpc_id.clone(),
4472            status: p.status.clone(),
4473            tags: p.tags.clone(),
4474            requester_peering_options: p.requester_peering_options.as_ref().map(|o| {
4475                VpcPeeringConnectionOptionsView {
4476                    allow_dns_resolution_from_remote_vpc: o.allow_dns_resolution_from_remote_vpc,
4477                    allow_egress_from_local_classic_link_to_remote_vpc: o
4478                        .allow_egress_from_local_classic_link_to_remote_vpc,
4479                    allow_egress_from_local_vpc_to_remote_classic_link: o
4480                        .allow_egress_from_local_vpc_to_remote_classic_link,
4481                }
4482            }),
4483            accepter_peering_options: p.accepter_peering_options.as_ref().map(|o| {
4484                VpcPeeringConnectionOptionsView {
4485                    allow_dns_resolution_from_remote_vpc: o.allow_dns_resolution_from_remote_vpc,
4486                    allow_egress_from_local_classic_link_to_remote_vpc: o
4487                        .allow_egress_from_local_classic_link_to_remote_vpc,
4488                    allow_egress_from_local_vpc_to_remote_classic_link: o
4489                        .allow_egress_from_local_vpc_to_remote_classic_link,
4490                }
4491            }),
4492        }
4493    }
4494}
4495
4496impl From<&VpcEndpoint> for VpcEndpointView {
4497    fn from(e: &VpcEndpoint) -> Self {
4498        VpcEndpointView {
4499            endpoint_id: e.endpoint_id.clone(),
4500            vpc_id: e.vpc_id.clone(),
4501            service_name: e.service_name.clone(),
4502            endpoint_type: e.endpoint_type.clone(),
4503            state: e.state.clone(),
4504            policy_document: e.policy_document.clone(),
4505            route_table_ids: e.route_table_ids.clone(),
4506            subnet_ids: e.subnet_ids.clone(),
4507            security_group_ids: e.security_group_ids.clone(),
4508            private_dns_enabled: e.private_dns_enabled,
4509            tags: e.tags.clone(),
4510        }
4511    }
4512}
4513
4514impl From<&ManagedPrefixList> for ManagedPrefixListView {
4515    fn from(m: &ManagedPrefixList) -> Self {
4516        ManagedPrefixListView {
4517            prefix_list_id: m.prefix_list_id.clone(),
4518            prefix_list_name: m.prefix_list_name.clone(),
4519            state: m.state.clone(),
4520            address_family: m.address_family.clone(),
4521            max_entries: m.max_entries,
4522            entries: m.entries.iter().map(PrefixListEntryView::from).collect(),
4523            tags: m.tags.clone(),
4524            version: m.version,
4525            version_history: m
4526                .version_history
4527                .iter()
4528                .map(|v| ManagedPrefixListVersionView {
4529                    version: v.version,
4530                    entries: v.entries.iter().map(PrefixListEntryView::from).collect(),
4531                })
4532                .collect(),
4533        }
4534    }
4535}
4536
4537impl From<&TypesPrefixListEntry> for PrefixListEntryView {
4538    fn from(e: &TypesPrefixListEntry) -> Self {
4539        PrefixListEntryView {
4540            cidr: e.cidr.clone(),
4541            description: e.description.clone(),
4542        }
4543    }
4544}
4545
4546impl From<&CustomerGateway> for CustomerGatewayView {
4547    fn from(c: &CustomerGateway) -> Self {
4548        CustomerGatewayView {
4549            customer_gateway_id: c.customer_gateway_id.clone(),
4550            bgp_asn: c.bgp_asn.clone(),
4551            ip_address: c.ip_address.clone(),
4552            gateway_type: c.gateway_type.clone(),
4553            state: c.state.clone(),
4554            tags: c.tags.clone(),
4555        }
4556    }
4557}
4558
4559impl From<&VpnGateway> for VpnGatewayView {
4560    fn from(v: &VpnGateway) -> Self {
4561        VpnGatewayView {
4562            vpn_gateway_id: v.vpn_gateway_id.clone(),
4563            gateway_type: v.gateway_type.clone(),
4564            state: v.state.clone(),
4565            amazon_side_asn: v.amazon_side_asn,
4566            vpc_attachments: v
4567                .vpc_attachments
4568                .iter()
4569                .map(VgwVpcAttachmentView::from)
4570                .collect(),
4571            tags: v.tags.clone(),
4572        }
4573    }
4574}
4575
4576impl From<&VgwVpcAttachment> for VgwVpcAttachmentView {
4577    fn from(a: &VgwVpcAttachment) -> Self {
4578        VgwVpcAttachmentView {
4579            vpc_id: a.vpc_id.clone(),
4580            state: a.state.clone(),
4581        }
4582    }
4583}
4584
4585impl From<&VpnConnection> for VpnConnectionView {
4586    fn from(c: &VpnConnection) -> Self {
4587        VpnConnectionView {
4588            vpn_connection_id: c.vpn_connection_id.clone(),
4589            vpn_gateway_id: c.vpn_gateway_id.clone(),
4590            customer_gateway_id: c.customer_gateway_id.clone(),
4591            transit_gateway_id: c.transit_gateway_id.clone(),
4592            connection_type: c.connection_type.clone(),
4593            state: c.state.clone(),
4594            tags: c.tags.clone(),
4595            routes: c.routes.iter().map(VpnStaticRouteView::from).collect(),
4596            options: c.options.as_ref().map(VpnConnectionOptionsView::from),
4597            tunnel_replacement_status: c.tunnel_replacement_status.clone(),
4598        }
4599    }
4600}
4601
4602impl From<&VpnStaticRoute> for VpnStaticRouteView {
4603    fn from(r: &VpnStaticRoute) -> Self {
4604        VpnStaticRouteView {
4605            destination_cidr_block: r.destination_cidr_block.clone(),
4606            source: r.source.clone(),
4607            state: r.state.clone(),
4608        }
4609    }
4610}
4611
4612impl From<&VpnConnectionOptions> for VpnConnectionOptionsView {
4613    fn from(o: &VpnConnectionOptions) -> Self {
4614        VpnConnectionOptionsView {
4615            local_ipv4_network_cidr: o.local_ipv4_network_cidr.clone(),
4616            local_ipv6_network_cidr: o.local_ipv6_network_cidr.clone(),
4617            remote_ipv4_network_cidr: o.remote_ipv4_network_cidr.clone(),
4618            remote_ipv6_network_cidr: o.remote_ipv6_network_cidr.clone(),
4619            tunnel_inside_ip_version: o.tunnel_inside_ip_version.clone(),
4620            static_routes_only: o.static_routes_only,
4621            tunnel_options: o
4622                .tunnel_options
4623                .iter()
4624                .map(VpnTunnelOptionsView::from)
4625                .collect(),
4626        }
4627    }
4628}
4629
4630impl From<&VpnTunnelOptions> for VpnTunnelOptionsView {
4631    fn from(t: &VpnTunnelOptions) -> Self {
4632        VpnTunnelOptionsView {
4633            tunnel_inside_cidr: t.tunnel_inside_cidr.clone(),
4634            tunnel_inside_ipv6_cidr: t.tunnel_inside_ipv6_cidr.clone(),
4635            pre_shared_key: t.pre_shared_key.clone(),
4636            outside_ip_address: t.outside_ip_address.clone(),
4637            certificate_arn: t.certificate_arn.clone(),
4638        }
4639    }
4640}
4641
4642impl From<&VpnConcentrator> for VpnConcentratorView {
4643    fn from(v: &VpnConcentrator) -> Self {
4644        VpnConcentratorView {
4645            vpn_concentrator_id: v.vpn_concentrator_id.clone(),
4646            concentrator_type: v.concentrator_type.clone(),
4647            state: v.state.clone(),
4648            transit_gateway_id: v.transit_gateway_id.clone(),
4649            transit_gateway_attachment_id: v.transit_gateway_attachment_id.clone(),
4650            tags: v.tags.clone(),
4651        }
4652    }
4653}
4654
4655impl From<&VpcEndpointConnection> for VpcEndpointConnectionView {
4656    fn from(c: &VpcEndpointConnection) -> Self {
4657        VpcEndpointConnectionView {
4658            service_id: c.service_id.clone(),
4659            vpc_endpoint_id: c.vpc_endpoint_id.clone(),
4660            vpc_endpoint_owner: c.vpc_endpoint_owner.clone(),
4661            vpc_endpoint_state: c.vpc_endpoint_state.clone(),
4662            creation_timestamp: c.creation_timestamp.clone(),
4663        }
4664    }
4665}
4666
4667impl From<&VpcEndpointConnectionNotification> for VpcEndpointConnectionNotificationView {
4668    fn from(n: &VpcEndpointConnectionNotification) -> Self {
4669        VpcEndpointConnectionNotificationView {
4670            connection_notification_id: n.connection_notification_id.clone(),
4671            connection_notification_arn: n.connection_notification_arn.clone(),
4672            connection_events: n.connection_events.clone(),
4673            connection_notification_state: n.connection_notification_state.clone(),
4674            connection_notification_type: n.connection_notification_type.clone(),
4675            service_id: n.service_id.clone(),
4676            vpc_endpoint_id: n.vpc_endpoint_id.clone(),
4677        }
4678    }
4679}
4680
4681impl From<&VpcBlockPublicAccessExclusion> for VpcBlockPublicAccessExclusionView {
4682    fn from(e: &VpcBlockPublicAccessExclusion) -> Self {
4683        VpcBlockPublicAccessExclusionView {
4684            exclusion_id: e.exclusion_id.clone(),
4685            internet_gateway_exclusion_mode: e.internet_gateway_exclusion_mode.clone(),
4686            resource_arn: e.resource_arn.clone(),
4687            state: e.state.clone(),
4688            creation_timestamp: e.creation_timestamp.clone(),
4689            last_update_timestamp: e.last_update_timestamp.clone(),
4690            tags: e.tags.clone(),
4691        }
4692    }
4693}
4694
4695impl From<&VpcBlockPublicAccessOptions> for VpcBlockPublicAccessOptionsView {
4696    fn from(o: &VpcBlockPublicAccessOptions) -> Self {
4697        VpcBlockPublicAccessOptionsView {
4698            aws_account_id: o.aws_account_id.clone(),
4699            aws_region: o.aws_region.clone(),
4700            internet_gateway_block_mode: o.internet_gateway_block_mode.clone(),
4701            state: o.state.clone(),
4702            last_update_timestamp: o.last_update_timestamp.clone(),
4703        }
4704    }
4705}
4706
4707impl From<&VpcEncryptionControl> for VpcEncryptionControlView {
4708    fn from(v: &VpcEncryptionControl) -> Self {
4709        VpcEncryptionControlView {
4710            vpc_encryption_control_id: v.vpc_encryption_control_id.clone(),
4711            vpc_id: v.vpc_id.clone(),
4712            mode: v.mode.clone(),
4713            state: v.state.clone(),
4714            mode_history: v.mode_history.clone(),
4715            tags: v.tags.clone(),
4716        }
4717    }
4718}
4719
4720impl From<&CarrierGateway> for CarrierGatewayView {
4721    fn from(c: &CarrierGateway) -> Self {
4722        CarrierGatewayView {
4723            carrier_gateway_id: c.carrier_gateway_id.clone(),
4724            vpc_id: c.vpc_id.clone(),
4725            state: c.state.clone(),
4726            tags: c.tags.clone(),
4727        }
4728    }
4729}
4730
4731impl From<&NetworkInterface> for NetworkInterfaceView {
4732    fn from(n: &NetworkInterface) -> Self {
4733        NetworkInterfaceView {
4734            network_interface_id: n.network_interface_id.clone(),
4735            subnet_id: n.subnet_id.clone(),
4736            vpc_id: n.vpc_id.clone(),
4737            description: n.description.clone(),
4738            private_ip_address: n.private_ip_address.clone(),
4739            status: n.status.clone(),
4740            attachment_id: n.attachment_id.clone(),
4741            instance_id: n.instance_id.clone(),
4742            device_index: n.device_index,
4743            security_groups: n.security_groups.clone(),
4744            source_dest_check: n.source_dest_check,
4745            tags: n.tags.clone(),
4746            public_ip_dns_hostname_type: n.public_ip_dns_hostname_type.clone(),
4747        }
4748    }
4749}
4750
4751impl From<&TransitGateway> for TransitGatewayView {
4752    fn from(t: &TransitGateway) -> Self {
4753        TransitGatewayView {
4754            transit_gateway_id: t.transit_gateway_id.clone(),
4755            state: t.state.clone(),
4756            amazon_side_asn: t.amazon_side_asn,
4757            description: t.description.clone(),
4758            dns_support: t.dns_support.clone(),
4759            vpn_ecmp_support: t.vpn_ecmp_support.clone(),
4760            multicast_support: t.multicast_support.clone(),
4761            tags: t.tags.clone(),
4762        }
4763    }
4764}
4765
4766impl From<&TransitGatewayVpcAttachment> for TgwVpcAttachmentView {
4767    fn from(a: &TransitGatewayVpcAttachment) -> Self {
4768        TgwVpcAttachmentView {
4769            attachment_id: a.attachment_id.clone(),
4770            transit_gateway_id: a.transit_gateway_id.clone(),
4771            vpc_id: a.vpc_id.clone(),
4772            subnet_ids: a.subnet_ids.clone(),
4773            state: a.state.clone(),
4774            tags: a.tags.clone(),
4775        }
4776    }
4777}
4778
4779impl From<&TransitGatewayPeeringAttachment> for TgwPeeringAttachmentView {
4780    fn from(a: &TransitGatewayPeeringAttachment) -> Self {
4781        TgwPeeringAttachmentView {
4782            attachment_id: a.attachment_id.clone(),
4783            transit_gateway_id: a.transit_gateway_id.clone(),
4784            peer_transit_gateway_id: a.peer_transit_gateway_id.clone(),
4785            peer_account_id: a.peer_account_id.clone(),
4786            peer_region: a.peer_region.clone(),
4787            state: a.state.clone(),
4788            tags: a.tags.clone(),
4789        }
4790    }
4791}
4792
4793impl From<&TransitGatewayRouteTable> for TgwRouteTableView {
4794    fn from(t: &TransitGatewayRouteTable) -> Self {
4795        TgwRouteTableView {
4796            route_table_id: t.route_table_id.clone(),
4797            transit_gateway_id: t.transit_gateway_id.clone(),
4798            state: t.state.clone(),
4799            default_association_route_table: t.default_association_route_table,
4800            default_propagation_route_table: t.default_propagation_route_table,
4801            tags: t.tags.clone(),
4802        }
4803    }
4804}
4805
4806impl From<&TransitGatewayRoute> for TgwRouteView {
4807    fn from(r: &TransitGatewayRoute) -> Self {
4808        TgwRouteView {
4809            destination_cidr_block: r.destination_cidr_block.clone(),
4810            route_type: r.route_type.clone(),
4811            state: r.state.clone(),
4812            attachment_id: r.attachment_id.clone(),
4813        }
4814    }
4815}
4816
4817// --- Group 11: Transit Gateway extension From impls ---
4818
4819impl From<&TransitGatewayMulticastDomain> for TransitGatewayMulticastDomainView {
4820    fn from(d: &TransitGatewayMulticastDomain) -> Self {
4821        TransitGatewayMulticastDomainView {
4822            transit_gateway_multicast_domain_id: d.transit_gateway_multicast_domain_id.clone(),
4823            transit_gateway_id: d.transit_gateway_id.clone(),
4824            transit_gateway_multicast_domain_arn: d.transit_gateway_multicast_domain_arn.clone(),
4825            owner_id: d.owner_id.clone(),
4826            igmpv2_support: d.igmpv2_support.clone(),
4827            static_sources_support: d.static_sources_support.clone(),
4828            auto_accept_shared_associations: d.auto_accept_shared_associations.clone(),
4829            state: d.state.clone(),
4830            creation_time: d.creation_time.clone(),
4831            tags: d.tags.clone(),
4832        }
4833    }
4834}
4835
4836impl From<&MulticastSubnetAssociation> for MulticastSubnetAssociationView {
4837    fn from(s: &MulticastSubnetAssociation) -> Self {
4838        MulticastSubnetAssociationView {
4839            subnet_id: s.subnet_id.clone(),
4840            state: s.state.clone(),
4841        }
4842    }
4843}
4844
4845impl From<&TransitGatewayMulticastDomainAssociation>
4846    for TransitGatewayMulticastDomainAssociationView
4847{
4848    fn from(a: &TransitGatewayMulticastDomainAssociation) -> Self {
4849        TransitGatewayMulticastDomainAssociationView {
4850            transit_gateway_multicast_domain_id: a.transit_gateway_multicast_domain_id.clone(),
4851            transit_gateway_attachment_id: a.transit_gateway_attachment_id.clone(),
4852            resource_id: a.resource_id.clone(),
4853            resource_type: a.resource_type.clone(),
4854            subnets: a
4855                .subnets
4856                .iter()
4857                .map(MulticastSubnetAssociationView::from)
4858                .collect(),
4859        }
4860    }
4861}
4862
4863impl From<&TransitGatewayMulticastGroupMember> for TransitGatewayMulticastGroupMemberView {
4864    fn from(m: &TransitGatewayMulticastGroupMember) -> Self {
4865        TransitGatewayMulticastGroupMemberView {
4866            transit_gateway_multicast_domain_id: m.transit_gateway_multicast_domain_id.clone(),
4867            group_ip_address: m.group_ip_address.clone(),
4868            transit_gateway_attachment_id: m.transit_gateway_attachment_id.clone(),
4869            subnet_id: m.subnet_id.clone(),
4870            resource_id: m.resource_id.clone(),
4871            resource_type: m.resource_type.clone(),
4872            network_interface_id: m.network_interface_id.clone(),
4873            member_type: m.member_type.clone(),
4874            source_type: m.source_type.clone(),
4875        }
4876    }
4877}
4878
4879impl From<&TransitGatewayMulticastGroupSource> for TransitGatewayMulticastGroupSourceView {
4880    fn from(s: &TransitGatewayMulticastGroupSource) -> Self {
4881        TransitGatewayMulticastGroupSourceView {
4882            transit_gateway_multicast_domain_id: s.transit_gateway_multicast_domain_id.clone(),
4883            group_ip_address: s.group_ip_address.clone(),
4884            transit_gateway_attachment_id: s.transit_gateway_attachment_id.clone(),
4885            subnet_id: s.subnet_id.clone(),
4886            resource_id: s.resource_id.clone(),
4887            resource_type: s.resource_type.clone(),
4888            network_interface_id: s.network_interface_id.clone(),
4889            member_type: s.member_type.clone(),
4890            source_type: s.source_type.clone(),
4891        }
4892    }
4893}
4894
4895impl From<&TransitGatewayConnect> for TransitGatewayConnectView {
4896    fn from(c: &TransitGatewayConnect) -> Self {
4897        TransitGatewayConnectView {
4898            transit_gateway_attachment_id: c.transit_gateway_attachment_id.clone(),
4899            transport_transit_gateway_attachment_id: c
4900                .transport_transit_gateway_attachment_id
4901                .clone(),
4902            transit_gateway_id: c.transit_gateway_id.clone(),
4903            state: c.state.clone(),
4904            creation_time: c.creation_time.clone(),
4905            protocol: c.protocol.clone(),
4906            tags: c.tags.clone(),
4907        }
4908    }
4909}
4910
4911impl From<&TransitGatewayAttachmentBgpConfiguration>
4912    for TransitGatewayAttachmentBgpConfigurationView
4913{
4914    fn from(b: &TransitGatewayAttachmentBgpConfiguration) -> Self {
4915        TransitGatewayAttachmentBgpConfigurationView {
4916            transit_gateway_asn: b.transit_gateway_asn,
4917            peer_asn: b.peer_asn,
4918            transit_gateway_address: b.transit_gateway_address.clone(),
4919            peer_address: b.peer_address.clone(),
4920            bgp_status: b.bgp_status.clone(),
4921        }
4922    }
4923}
4924
4925impl From<&TransitGatewayConnectPeer> for TransitGatewayConnectPeerView {
4926    fn from(p: &TransitGatewayConnectPeer) -> Self {
4927        TransitGatewayConnectPeerView {
4928            transit_gateway_attachment_id: p.transit_gateway_attachment_id.clone(),
4929            transit_gateway_connect_peer_id: p.transit_gateway_connect_peer_id.clone(),
4930            state: p.state.clone(),
4931            creation_time: p.creation_time.clone(),
4932            transit_gateway_address: p.transit_gateway_address.clone(),
4933            peer_address: p.peer_address.clone(),
4934            inside_cidr_blocks: p.inside_cidr_blocks.clone(),
4935            protocol: p.protocol.clone(),
4936            bgp_configurations: p
4937                .bgp_configurations
4938                .iter()
4939                .map(TransitGatewayAttachmentBgpConfigurationView::from)
4940                .collect(),
4941            tags: p.tags.clone(),
4942        }
4943    }
4944}
4945
4946impl From<&TransitGatewayMeteringPolicy> for TransitGatewayMeteringPolicyView {
4947    fn from(p: &TransitGatewayMeteringPolicy) -> Self {
4948        TransitGatewayMeteringPolicyView {
4949            transit_gateway_metering_policy_id: p.transit_gateway_metering_policy_id.clone(),
4950            transit_gateway_metering_policy_arn: p.transit_gateway_metering_policy_arn.clone(),
4951            transit_gateway_id: p.transit_gateway_id.clone(),
4952            name: p.name.clone(),
4953            description: p.description.clone(),
4954            state: p.state.clone(),
4955            tags: p.tags.clone(),
4956            last_updated_time: p.last_updated_time.clone(),
4957            version: p.version,
4958            middlebox_attachment_ids: p.middlebox_attachment_ids.clone(),
4959        }
4960    }
4961}
4962
4963impl From<&TransitGatewayMeteringPolicyEntry> for TransitGatewayMeteringPolicyEntryView {
4964    fn from(e: &TransitGatewayMeteringPolicyEntry) -> Self {
4965        TransitGatewayMeteringPolicyEntryView {
4966            transit_gateway_metering_policy_entry_id: e
4967                .transit_gateway_metering_policy_entry_id
4968                .clone(),
4969            transit_gateway_metering_policy_id: e.transit_gateway_metering_policy_id.clone(),
4970            sequence_number: e.sequence_number,
4971            action: e.action.clone(),
4972            source_cidr_block: e.source_cidr_block.clone(),
4973            destination_cidr_block: e.destination_cidr_block.clone(),
4974            protocol: e.protocol.clone(),
4975            source_port: e.source_port.clone(),
4976            destination_port: e.destination_port.clone(),
4977            dimensions: e.dimensions.clone(),
4978            state: e.state.clone(),
4979        }
4980    }
4981}
4982
4983impl From<&TransitGatewayPolicyTable> for TransitGatewayPolicyTableView {
4984    fn from(p: &TransitGatewayPolicyTable) -> Self {
4985        TransitGatewayPolicyTableView {
4986            transit_gateway_policy_table_id: p.transit_gateway_policy_table_id.clone(),
4987            transit_gateway_id: p.transit_gateway_id.clone(),
4988            state: p.state.clone(),
4989            creation_time: p.creation_time.clone(),
4990            tags: p.tags.clone(),
4991        }
4992    }
4993}
4994
4995impl From<&TransitGatewayPolicyTableAssociation> for TransitGatewayPolicyTableAssociationView {
4996    fn from(a: &TransitGatewayPolicyTableAssociation) -> Self {
4997        TransitGatewayPolicyTableAssociationView {
4998            transit_gateway_policy_table_id: a.transit_gateway_policy_table_id.clone(),
4999            transit_gateway_attachment_id: a.transit_gateway_attachment_id.clone(),
5000            resource_type: a.resource_type.clone(),
5001            resource_id: a.resource_id.clone(),
5002            state: a.state.clone(),
5003        }
5004    }
5005}
5006
5007impl From<&TransitGatewayPrefixListReference> for TransitGatewayPrefixListReferenceView {
5008    fn from(r: &TransitGatewayPrefixListReference) -> Self {
5009        TransitGatewayPrefixListReferenceView {
5010            transit_gateway_route_table_id: r.transit_gateway_route_table_id.clone(),
5011            prefix_list_id: r.prefix_list_id.clone(),
5012            prefix_list_owner_id: r.prefix_list_owner_id.clone(),
5013            state: r.state.clone(),
5014            blackhole: r.blackhole,
5015            transit_gateway_attachment_id: r.transit_gateway_attachment_id.clone(),
5016            resource_id: r.resource_id.clone(),
5017            resource_type: r.resource_type.clone(),
5018        }
5019    }
5020}
5021
5022impl From<&TransitGatewayRouteTableAnnouncement> for TransitGatewayRouteTableAnnouncementView {
5023    fn from(a: &TransitGatewayRouteTableAnnouncement) -> Self {
5024        TransitGatewayRouteTableAnnouncementView {
5025            transit_gateway_route_table_announcement_id: a
5026                .transit_gateway_route_table_announcement_id
5027                .clone(),
5028            transit_gateway_id: a.transit_gateway_id.clone(),
5029            core_network_id: a.core_network_id.clone(),
5030            peer_transit_gateway_id: a.peer_transit_gateway_id.clone(),
5031            peer_core_network_id: a.peer_core_network_id.clone(),
5032            peering_attachment_id: a.peering_attachment_id.clone(),
5033            announcement_direction: a.announcement_direction.clone(),
5034            transit_gateway_route_table_id: a.transit_gateway_route_table_id.clone(),
5035            state: a.state.clone(),
5036            creation_time: a.creation_time.clone(),
5037            tags: a.tags.clone(),
5038        }
5039    }
5040}
5041
5042impl From<&Instance> for InstanceView {
5043    fn from(i: &Instance) -> Self {
5044        InstanceView {
5045            instance_id: i.instance_id.clone(),
5046            image_id: i.image_id.clone(),
5047            instance_type: i.instance_type.clone(),
5048            state: InstanceStateView {
5049                code: i.state.code,
5050                name: i.state.name.clone(),
5051            },
5052            private_ip_address: i.private_ip_address.clone(),
5053            public_ip_address: i.public_ip_address.clone(),
5054            subnet_id: i.subnet_id.clone(),
5055            vpc_id: i.vpc_id.clone(),
5056            key_name: i.key_name.clone(),
5057            security_groups: i.security_groups.clone(),
5058            launch_time: i.launch_time.clone(),
5059            tags: i.tags.clone(),
5060            iam_instance_profile_arn: i.iam_instance_profile_arn.clone(),
5061            monitoring_state: i.monitoring_state.clone(),
5062            placement_az: i.placement_az.clone(),
5063            placement_group_name: i.placement_group_name.clone(),
5064            placement_tenancy: i.placement_tenancy.clone(),
5065            placement_host_id: i.placement_host_id.clone(),
5066            placement_affinity: i.placement_affinity.clone(),
5067            placement_partition_number: i.placement_partition_number,
5068            owner_id: i.owner_id.clone(),
5069            classic_link_vpc: i.classic_link_vpc.clone(),
5070            private_dns_hostname_type: i.private_dns_hostname_type.clone(),
5071            enable_resource_name_dns_a_record: i.enable_resource_name_dns_a_record,
5072            enable_resource_name_dns_aaaa_record: i.enable_resource_name_dns_aaaa_record,
5073            credit_specification: i.credit_specification.clone(),
5074            cpu_options: i.cpu_options.as_ref().map(|c| InstanceCpuOptionsView {
5075                core_count: c.core_count,
5076                threads_per_core: c.threads_per_core,
5077                amd_sev_snp: c.amd_sev_snp.clone(),
5078            }),
5079            maintenance_options: i.maintenance_options.as_ref().map(|m| {
5080                InstanceMaintenanceOptionsView {
5081                    auto_recovery: m.auto_recovery.clone(),
5082                    reboot_migration: m.reboot_migration.clone(),
5083                }
5084            }),
5085            network_bandwidth_weighting: i.network_bandwidth_weighting.clone(),
5086            lifecycle: i.lifecycle.clone(),
5087            product_codes: i.product_codes.clone(),
5088            capacity_reservation_specification: i
5089                .capacity_reservation_specification
5090                .as_ref()
5091                .map(CapacityReservationSpecificationResponseView::from),
5092        }
5093    }
5094}
5095
5096impl From<&VolumeAttachment> for VolumeAttachmentView {
5097    fn from(a: &VolumeAttachment) -> Self {
5098        VolumeAttachmentView {
5099            volume_id: a.volume_id.clone(),
5100            instance_id: a.instance_id.clone(),
5101            device: a.device.clone(),
5102            state: a.state.clone(),
5103            attach_time: a.attach_time.clone(),
5104            delete_on_termination: a.delete_on_termination,
5105        }
5106    }
5107}
5108
5109impl From<&Volume> for VolumeView {
5110    fn from(v: &Volume) -> Self {
5111        VolumeView {
5112            volume_id: v.volume_id.clone(),
5113            size: v.size,
5114            snapshot_id: v.snapshot_id.clone(),
5115            availability_zone: v.availability_zone.clone(),
5116            state: v.state.clone(),
5117            volume_type: v.volume_type.clone(),
5118            iops: v.iops,
5119            throughput: v.throughput,
5120            encrypted: v.encrypted,
5121            create_time: v.create_time.clone(),
5122            attachments: v
5123                .attachments
5124                .iter()
5125                .map(VolumeAttachmentView::from)
5126                .collect(),
5127            tags: v.tags.clone(),
5128            recycle_bin_state: v.recycle_bin_state.clone(),
5129            source_volume_id: v.source_volume_id.clone(),
5130        }
5131    }
5132}
5133
5134impl From<&Snapshot> for SnapshotView {
5135    fn from(s: &Snapshot) -> Self {
5136        SnapshotView {
5137            snapshot_id: s.snapshot_id.clone(),
5138            volume_id: s.volume_id.clone(),
5139            volume_size: s.volume_size,
5140            state: s.state.clone(),
5141            description: s.description.clone(),
5142            start_time: s.start_time.clone(),
5143            progress: s.progress.clone(),
5144            owner_id: s.owner_id.clone(),
5145            encrypted: s.encrypted,
5146            tags: s.tags.clone(),
5147            lock_state: s.lock_state.clone(),
5148            lock_duration: s.lock_duration,
5149            lock_created_on: s.lock_created_on.clone(),
5150            lock_expires_on: s.lock_expires_on.clone(),
5151            lock_duration_start_time: s.lock_duration_start_time.clone(),
5152            cool_off_period: s.cool_off_period,
5153            cool_off_period_expires_on: s.cool_off_period_expires_on.clone(),
5154            storage_tier: s.storage_tier.clone(),
5155            last_tiering_operation_status: s.last_tiering_operation_status.clone(),
5156            fast_snapshot_restore_states: s
5157                .fast_snapshot_restore_states
5158                .iter()
5159                .map(|f| FastSnapshotRestoreStateView {
5160                    availability_zone: f.availability_zone.clone(),
5161                    state: f.state.clone(),
5162                })
5163                .collect(),
5164        }
5165    }
5166}
5167
5168impl From<&Image> for ImageView {
5169    fn from(i: &Image) -> Self {
5170        ImageView {
5171            image_id: i.image_id.clone(),
5172            name: i.name.clone(),
5173            description: i.description.clone(),
5174            state: i.state.clone(),
5175            owner_id: i.owner_id.clone(),
5176            architecture: i.architecture.clone(),
5177            image_type: i.image_type.clone(),
5178            platform: i.platform.clone(),
5179            virtualization_type: i.virtualization_type.clone(),
5180            root_device_type: i.root_device_type.clone(),
5181            root_device_name: i.root_device_name.clone(),
5182            public: i.public,
5183            tags: i.tags.clone(),
5184            source_instance_id: i.source_instance_id.clone(),
5185            source_instance_type: i.source_instance_type.clone(),
5186            launch_permissions: i
5187                .launch_permissions
5188                .iter()
5189                .map(LaunchPermissionView::from)
5190                .collect(),
5191            recycle_bin_state: i.recycle_bin_state.clone(),
5192            deprecation_time: i.deprecation_time.clone(),
5193            recycle_bin_enter_time: i.recycle_bin_enter_time.clone(),
5194            product_codes: i.product_codes.clone(),
5195            fast_launch_state: i.fast_launch_state.as_ref().map(FastLaunchStateView::from),
5196            deregistration_protection: i.deregistration_protection.clone(),
5197            kernel_id: i.kernel_id.clone(),
5198            ramdisk_id: i.ramdisk_id.clone(),
5199            ena_support: i.ena_support,
5200            sriov_net_support: i.sriov_net_support.clone(),
5201            tpm_support: i.tpm_support.clone(),
5202            boot_mode: i.boot_mode.clone(),
5203            imds_support: i.imds_support.clone(),
5204            image_location: i.image_location.clone(),
5205            source_image_id: i.source_image_id.clone(),
5206            source_region: i.source_region.clone(),
5207        }
5208    }
5209}
5210
5211impl From<&crate::types::FastLaunchState> for FastLaunchStateView {
5212    fn from(f: &crate::types::FastLaunchState) -> Self {
5213        FastLaunchStateView {
5214            state: f.state.clone(),
5215            image_id: f.image_id.clone(),
5216            resource_type: f.resource_type.clone(),
5217            snapshot_configuration: SnapshotConfigurationRequestView {
5218                target_resource_count: f.snapshot_configuration.target_resource_count,
5219            },
5220            launch_template: FastLaunchLaunchTemplateSpecificationView {
5221                launch_template_id: f.launch_template.launch_template_id.clone(),
5222                launch_template_name: f.launch_template.launch_template_name.clone(),
5223                version: f.launch_template.version.clone(),
5224            },
5225            max_parallel_launches: f.max_parallel_launches,
5226            owner_id: f.owner_id.clone(),
5227            state_transition_time: f.state_transition_time.clone(),
5228        }
5229    }
5230}
5231
5232impl From<FastLaunchStateView> for crate::types::FastLaunchState {
5233    fn from(v: FastLaunchStateView) -> Self {
5234        crate::types::FastLaunchState {
5235            state: v.state,
5236            image_id: v.image_id,
5237            resource_type: v.resource_type,
5238            snapshot_configuration: crate::types::SnapshotConfigurationRequest {
5239                target_resource_count: v.snapshot_configuration.target_resource_count,
5240            },
5241            launch_template: crate::types::FastLaunchLaunchTemplateSpecification {
5242                launch_template_id: v.launch_template.launch_template_id,
5243                launch_template_name: v.launch_template.launch_template_name,
5244                version: v.launch_template.version,
5245            },
5246            max_parallel_launches: v.max_parallel_launches,
5247            owner_id: v.owner_id,
5248            state_transition_time: v.state_transition_time,
5249        }
5250    }
5251}
5252
5253impl From<&crate::types::LaunchPermission> for LaunchPermissionView {
5254    fn from(p: &crate::types::LaunchPermission) -> Self {
5255        LaunchPermissionView {
5256            user_id: p.user_id.clone(),
5257            group: p.group.clone(),
5258        }
5259    }
5260}
5261
5262impl From<&LaunchTemplate> for LaunchTemplateView {
5263    fn from(t: &LaunchTemplate) -> Self {
5264        LaunchTemplateView {
5265            launch_template_id: t.launch_template_id.clone(),
5266            launch_template_name: t.launch_template_name.clone(),
5267            default_version_number: t.default_version_number,
5268            latest_version_number: t.latest_version_number,
5269            tags: t.tags.clone(),
5270        }
5271    }
5272}
5273
5274impl From<&LaunchTemplateVersion> for LaunchTemplateVersionView {
5275    fn from(v: &LaunchTemplateVersion) -> Self {
5276        LaunchTemplateVersionView {
5277            version_number: v.version_number,
5278            launch_template_id: v.launch_template_id.clone(),
5279            launch_template_name: v.launch_template_name.clone(),
5280            version_description: v.version_description.clone(),
5281            data: v.data.clone(),
5282            default_version: v.default_version,
5283        }
5284    }
5285}
5286
5287impl From<&SpotInstanceRequest> for SpotInstanceRequestView {
5288    fn from(s: &SpotInstanceRequest) -> Self {
5289        SpotInstanceRequestView {
5290            spot_instance_request_id: s.spot_instance_request_id.clone(),
5291            spot_price: s.spot_price.clone(),
5292            instance_type: s.instance_type.clone(),
5293            image_id: s.image_id.clone(),
5294            state: s.state.clone(),
5295            status_code: s.status_code.clone(),
5296            instance_id: s.instance_id.clone(),
5297            tags: s.tags.clone(),
5298        }
5299    }
5300}
5301
5302impl From<&crate::types::SpotDatafeedSubscription> for SpotDatafeedSubscriptionView {
5303    fn from(s: &crate::types::SpotDatafeedSubscription) -> Self {
5304        SpotDatafeedSubscriptionView {
5305            bucket: s.bucket.clone(),
5306            prefix: s.prefix.clone(),
5307            owner_id: s.owner_id.clone(),
5308            state: s.state.clone(),
5309        }
5310    }
5311}
5312
5313impl From<&IamInstanceProfileAssociation> for IamInstanceProfileAssociationView {
5314    fn from(a: &IamInstanceProfileAssociation) -> Self {
5315        IamInstanceProfileAssociationView {
5316            association_id: a.association_id.clone(),
5317            instance_id: a.instance_id.clone(),
5318            iam_instance_profile_arn: a.iam_instance_profile_arn.clone(),
5319            iam_instance_profile_name: a.iam_instance_profile_name.clone(),
5320            state: a.state.clone(),
5321        }
5322    }
5323}
5324
5325impl From<&DedicatedHost> for DedicatedHostView {
5326    fn from(h: &DedicatedHost) -> Self {
5327        DedicatedHostView {
5328            host_id: h.host_id.clone(),
5329            availability_zone: h.availability_zone.clone(),
5330            instance_type: h.instance_type.clone(),
5331            auto_placement: h.auto_placement.clone(),
5332            host_recovery: h.host_recovery.clone(),
5333            state: h.state.clone(),
5334            tags: h.tags.clone(),
5335        }
5336    }
5337}
5338
5339impl From<&Ec2Fleet> for Ec2FleetView {
5340    fn from(f: &Ec2Fleet) -> Self {
5341        Ec2FleetView {
5342            fleet_id: f.fleet_id.clone(),
5343            state: f.state.clone(),
5344            fleet_type: f.fleet_type.clone(),
5345            create_time: f.create_time.clone(),
5346            tags: f.tags.clone(),
5347            total_target_capacity: f.total_target_capacity,
5348            on_demand_target_capacity: f.on_demand_target_capacity,
5349            spot_target_capacity: f.spot_target_capacity,
5350            context: f.context.clone(),
5351        }
5352    }
5353}
5354
5355impl From<&VpcEndpointServiceConfiguration> for VpcEndpointServiceConfigView {
5356    fn from(s: &VpcEndpointServiceConfiguration) -> Self {
5357        VpcEndpointServiceConfigView {
5358            service_id: s.service_id.clone(),
5359            service_name: s.service_name.clone(),
5360            service_type: s.service_type.clone(),
5361            acceptance_required: s.acceptance_required,
5362            state: s.state.clone(),
5363            network_load_balancer_arns: s.network_load_balancer_arns.clone(),
5364            gateway_load_balancer_arns: s.gateway_load_balancer_arns.clone(),
5365            allowed_principals: s.allowed_principals.clone(),
5366            tags: s.tags.clone(),
5367            payer_responsibility: s.payer_responsibility.clone(),
5368            private_dns_state: s.private_dns_state.clone(),
5369        }
5370    }
5371}
5372
5373impl From<&SpotFleetRequest> for SpotFleetRequestView {
5374    fn from(s: &SpotFleetRequest) -> Self {
5375        SpotFleetRequestView {
5376            spot_fleet_request_id: s.spot_fleet_request_id.clone(),
5377            spot_fleet_request_state: s.spot_fleet_request_state.clone(),
5378            target_capacity: s.target_capacity,
5379            iam_fleet_role: s.iam_fleet_role.clone(),
5380            create_time: s.create_time.clone(),
5381            tags: s.tags.clone(),
5382        }
5383    }
5384}
5385
5386impl From<&SubnetCidrReservationEntry> for SubnetCidrReservationView {
5387    fn from(r: &SubnetCidrReservationEntry) -> Self {
5388        SubnetCidrReservationView {
5389            reservation_id: r.reservation_id.clone(),
5390            subnet_id: r.subnet_id.clone(),
5391            cidr: r.cidr.clone(),
5392            reservation_type: r.reservation_type.clone(),
5393            description: r.description.clone(),
5394            owner_id: r.owner_id.clone(),
5395        }
5396    }
5397}
5398
5399impl From<&PlacementGroup> for PlacementGroupView {
5400    fn from(p: &PlacementGroup) -> Self {
5401        PlacementGroupView {
5402            group_id: p.group_id.clone(),
5403            group_name: p.group_name.clone(),
5404            group_arn: p.group_arn.clone(),
5405            strategy: p.strategy.clone(),
5406            state: p.state.clone(),
5407            partition_count: p.partition_count,
5408            spread_level: p.spread_level.clone(),
5409            tags: p.tags.clone(),
5410        }
5411    }
5412}
5413
5414impl From<&NetworkInterfacePermission> for NetworkInterfacePermissionView {
5415    fn from(p: &NetworkInterfacePermission) -> Self {
5416        NetworkInterfacePermissionView {
5417            network_interface_permission_id: p.network_interface_permission_id.clone(),
5418            network_interface_id: p.network_interface_id.clone(),
5419            aws_account_id: p.aws_account_id.clone(),
5420            aws_service: p.aws_service.clone(),
5421            permission: p.permission.clone(),
5422            permission_state: p.permission_state.clone(),
5423        }
5424    }
5425}
5426
5427impl From<&CapacityReservation> for CapacityReservationView {
5428    fn from(c: &CapacityReservation) -> Self {
5429        CapacityReservationView {
5430            capacity_reservation_id: c.capacity_reservation_id.clone(),
5431            capacity_reservation_arn: c.capacity_reservation_arn.clone(),
5432            owner_id: c.owner_id.clone(),
5433            instance_type: c.instance_type.clone(),
5434            instance_platform: c.instance_platform.clone(),
5435            availability_zone: c.availability_zone.clone(),
5436            tenancy: c.tenancy.clone(),
5437            total_instance_count: c.total_instance_count,
5438            available_instance_count: c.available_instance_count,
5439            ebs_optimized: c.ebs_optimized,
5440            ephemeral_storage: c.ephemeral_storage,
5441            state: c.state.clone(),
5442            start_date: c.start_date.clone(),
5443            end_date: c.end_date.clone(),
5444            end_date_type: c.end_date_type.clone(),
5445            instance_match_criteria: c.instance_match_criteria.clone(),
5446            create_date: c.create_date.clone(),
5447            outpost_arn: c.outpost_arn.clone(),
5448            placement_group_arn: c.placement_group_arn.clone(),
5449            tags: c.tags.clone(),
5450            pending_billing_owner_account_id: c.pending_billing_owner_account_id.clone(),
5451            billing_owner_account_id: c.billing_owner_account_id.clone(),
5452            target_capacity_reservation_id: c.target_capacity_reservation_id.clone(),
5453            reservation_type: c.reservation_type.clone(),
5454            commitment_info: c
5455                .commitment_info
5456                .as_ref()
5457                .map(CapacityReservationCommitmentInfoView::from),
5458        }
5459    }
5460}
5461
5462impl From<&CapacityReservationCommitmentInfo> for CapacityReservationCommitmentInfoView {
5463    fn from(c: &CapacityReservationCommitmentInfo) -> Self {
5464        CapacityReservationCommitmentInfoView {
5465            commitment_end_date: c.commitment_end_date.clone(),
5466            committed_instance_count: c.committed_instance_count,
5467        }
5468    }
5469}
5470
5471impl From<CapacityReservationCommitmentInfoView> for CapacityReservationCommitmentInfo {
5472    fn from(c: CapacityReservationCommitmentInfoView) -> Self {
5473        CapacityReservationCommitmentInfo {
5474            commitment_end_date: c.commitment_end_date,
5475            committed_instance_count: c.committed_instance_count,
5476        }
5477    }
5478}
5479
5480impl From<&CapacityReservationSpecificationResponse>
5481    for CapacityReservationSpecificationResponseView
5482{
5483    fn from(s: &CapacityReservationSpecificationResponse) -> Self {
5484        CapacityReservationSpecificationResponseView {
5485            capacity_reservation_preference: s.capacity_reservation_preference.clone(),
5486            capacity_reservation_id: s.capacity_reservation_id.clone(),
5487            capacity_reservation_resource_group_arn: s
5488                .capacity_reservation_resource_group_arn
5489                .clone(),
5490        }
5491    }
5492}
5493
5494impl From<CapacityReservationSpecificationResponseView>
5495    for CapacityReservationSpecificationResponse
5496{
5497    fn from(s: CapacityReservationSpecificationResponseView) -> Self {
5498        CapacityReservationSpecificationResponse {
5499            capacity_reservation_preference: s.capacity_reservation_preference,
5500            capacity_reservation_id: s.capacity_reservation_id,
5501            capacity_reservation_resource_group_arn: s.capacity_reservation_resource_group_arn,
5502        }
5503    }
5504}
5505
5506impl From<&BillingOwnershipOffer> for BillingOwnershipOfferView {
5507    fn from(o: &BillingOwnershipOffer) -> Self {
5508        BillingOwnershipOfferView {
5509            capacity_reservation_id: o.capacity_reservation_id.clone(),
5510            unused_reservation_billing_owner_id: o.unused_reservation_billing_owner_id.clone(),
5511            requested_by: o.requested_by.clone(),
5512            status: o.status.clone(),
5513            status_message: o.status_message.clone(),
5514            last_update_time: o.last_update_time.clone(),
5515        }
5516    }
5517}
5518
5519impl From<BillingOwnershipOfferView> for BillingOwnershipOffer {
5520    fn from(o: BillingOwnershipOfferView) -> Self {
5521        BillingOwnershipOffer {
5522            capacity_reservation_id: o.capacity_reservation_id,
5523            unused_reservation_billing_owner_id: o.unused_reservation_billing_owner_id,
5524            requested_by: o.requested_by,
5525            status: o.status,
5526            status_message: o.status_message,
5527            last_update_time: o.last_update_time,
5528        }
5529    }
5530}
5531
5532impl From<&S3DestinationOptions> for S3DestinationOptionsView {
5533    fn from(s: &S3DestinationOptions) -> Self {
5534        S3DestinationOptionsView {
5535            bucket: s.bucket.clone(),
5536            prefix: s.prefix.clone(),
5537        }
5538    }
5539}
5540
5541impl From<S3DestinationOptionsView> for S3DestinationOptions {
5542    fn from(s: S3DestinationOptionsView) -> Self {
5543        S3DestinationOptions {
5544            bucket: s.bucket,
5545            prefix: s.prefix,
5546        }
5547    }
5548}
5549
5550impl From<&CapacityManagerDataExport> for CapacityManagerDataExportView {
5551    fn from(e: &CapacityManagerDataExport) -> Self {
5552        CapacityManagerDataExportView {
5553            data_export_id: e.data_export_id.clone(),
5554            schedule: e.schedule.clone(),
5555            organization_account_ids: e.organization_account_ids.clone(),
5556            output_format: e.output_format.clone(),
5557            s3_destination: S3DestinationOptionsView::from(&e.s3_destination),
5558            status: e.status.clone(),
5559            status_message: e.status_message.clone(),
5560            last_export_time: e.last_export_time.clone(),
5561            next_export_time: e.next_export_time.clone(),
5562            create_time: e.create_time.clone(),
5563            tags: e.tags.clone(),
5564        }
5565    }
5566}
5567
5568impl From<CapacityManagerDataExportView> for CapacityManagerDataExport {
5569    fn from(e: CapacityManagerDataExportView) -> Self {
5570        CapacityManagerDataExport {
5571            data_export_id: e.data_export_id,
5572            schedule: e.schedule,
5573            organization_account_ids: e.organization_account_ids,
5574            output_format: e.output_format,
5575            s3_destination: S3DestinationOptions::from(e.s3_destination),
5576            status: e.status,
5577            status_message: e.status_message,
5578            last_export_time: e.last_export_time,
5579            next_export_time: e.next_export_time,
5580            create_time: e.create_time,
5581            tags: e.tags,
5582        }
5583    }
5584}
5585
5586impl From<&CapacityManagerOrganizationsAccess> for CapacityManagerOrganizationsAccessView {
5587    fn from(a: &CapacityManagerOrganizationsAccess) -> Self {
5588        CapacityManagerOrganizationsAccessView {
5589            state: a.state.clone(),
5590            last_updated_time: a.last_updated_time.clone(),
5591        }
5592    }
5593}
5594
5595impl From<CapacityManagerOrganizationsAccessView> for CapacityManagerOrganizationsAccess {
5596    fn from(a: CapacityManagerOrganizationsAccessView) -> Self {
5597        CapacityManagerOrganizationsAccess {
5598            state: a.state,
5599            last_updated_time: a.last_updated_time,
5600        }
5601    }
5602}
5603
5604impl From<&InterruptibleCapacityReservationAllocation>
5605    for InterruptibleCapacityReservationAllocationView
5606{
5607    fn from(a: &InterruptibleCapacityReservationAllocation) -> Self {
5608        InterruptibleCapacityReservationAllocationView {
5609            allocation_id: a.allocation_id.clone(),
5610            capacity_reservation_id: a.capacity_reservation_id.clone(),
5611            instance_count: a.instance_count,
5612            start_date_time: a.start_date_time.clone(),
5613            end_date_time: a.end_date_time.clone(),
5614            state: a.state.clone(),
5615            allocation_type: a.allocation_type.clone(),
5616            tags: a.tags.clone(),
5617        }
5618    }
5619}
5620
5621impl From<InterruptibleCapacityReservationAllocationView>
5622    for InterruptibleCapacityReservationAllocation
5623{
5624    fn from(a: InterruptibleCapacityReservationAllocationView) -> Self {
5625        InterruptibleCapacityReservationAllocation {
5626            allocation_id: a.allocation_id,
5627            capacity_reservation_id: a.capacity_reservation_id,
5628            instance_count: a.instance_count,
5629            start_date_time: a.start_date_time,
5630            end_date_time: a.end_date_time,
5631            state: a.state,
5632            allocation_type: a.allocation_type,
5633            tags: a.tags,
5634        }
5635    }
5636}
5637
5638impl From<&CapacityBlock> for CapacityBlockView {
5639    fn from(b: &CapacityBlock) -> Self {
5640        CapacityBlockView {
5641            capacity_block_id: b.capacity_block_id.clone(),
5642            capacity_reservation_id: b.capacity_reservation_id.clone(),
5643            capacity_block_offering_id: b.capacity_block_offering_id.clone(),
5644            instance_type: b.instance_type.clone(),
5645            instance_count: b.instance_count,
5646            availability_zone: b.availability_zone.clone(),
5647            start_date: b.start_date.clone(),
5648            end_date: b.end_date.clone(),
5649            tenancy: b.tenancy.clone(),
5650            currency_code: b.currency_code.clone(),
5651            upfront_fee: b.upfront_fee.clone(),
5652            commitment_duration_in_seconds: b.commitment_duration_in_seconds,
5653            capacity_reservation_arn: b.capacity_reservation_arn.clone(),
5654            tags: b.tags.clone(),
5655        }
5656    }
5657}
5658
5659impl From<CapacityBlockView> for CapacityBlock {
5660    fn from(b: CapacityBlockView) -> Self {
5661        CapacityBlock {
5662            capacity_block_id: b.capacity_block_id,
5663            capacity_reservation_id: b.capacity_reservation_id,
5664            capacity_block_offering_id: b.capacity_block_offering_id,
5665            instance_type: b.instance_type,
5666            instance_count: b.instance_count,
5667            availability_zone: b.availability_zone,
5668            start_date: b.start_date,
5669            end_date: b.end_date,
5670            tenancy: b.tenancy,
5671            currency_code: b.currency_code,
5672            upfront_fee: b.upfront_fee,
5673            commitment_duration_in_seconds: b.commitment_duration_in_seconds,
5674            capacity_reservation_arn: b.capacity_reservation_arn,
5675            tags: b.tags,
5676        }
5677    }
5678}
5679
5680impl From<&CapacityBlockExtension> for CapacityBlockExtensionView {
5681    fn from(e: &CapacityBlockExtension) -> Self {
5682        CapacityBlockExtensionView {
5683            capacity_block_extension_id: e.capacity_block_extension_id.clone(),
5684            capacity_reservation_id: e.capacity_reservation_id.clone(),
5685            instance_type: e.instance_type.clone(),
5686            availability_zone: e.availability_zone.clone(),
5687            instance_count: e.instance_count,
5688            availability_zone_id: e.availability_zone_id.clone(),
5689            start_date: e.start_date.clone(),
5690            end_date: e.end_date.clone(),
5691            capacity_block_extension_offering_id: e.capacity_block_extension_offering_id.clone(),
5692            capacity_block_extension_status: e.capacity_block_extension_status.clone(),
5693            capacity_block_extension_purchase_date: e
5694                .capacity_block_extension_purchase_date
5695                .clone(),
5696            capacity_block_extension_duration_hours: e.capacity_block_extension_duration_hours,
5697            currency_code: e.currency_code.clone(),
5698            upfront_fee: e.upfront_fee.clone(),
5699            capacity_reservation_arn: e.capacity_reservation_arn.clone(),
5700            capacity_block_extension_arn: e.capacity_block_extension_arn.clone(),
5701        }
5702    }
5703}
5704
5705impl From<CapacityBlockExtensionView> for CapacityBlockExtension {
5706    fn from(e: CapacityBlockExtensionView) -> Self {
5707        CapacityBlockExtension {
5708            capacity_block_extension_id: e.capacity_block_extension_id,
5709            capacity_reservation_id: e.capacity_reservation_id,
5710            instance_type: e.instance_type,
5711            availability_zone: e.availability_zone,
5712            instance_count: e.instance_count,
5713            availability_zone_id: e.availability_zone_id,
5714            start_date: e.start_date,
5715            end_date: e.end_date,
5716            capacity_block_extension_offering_id: e.capacity_block_extension_offering_id,
5717            capacity_block_extension_status: e.capacity_block_extension_status,
5718            capacity_block_extension_purchase_date: e.capacity_block_extension_purchase_date,
5719            capacity_block_extension_duration_hours: e.capacity_block_extension_duration_hours,
5720            currency_code: e.currency_code,
5721            upfront_fee: e.upfront_fee,
5722            capacity_reservation_arn: e.capacity_reservation_arn,
5723            capacity_block_extension_arn: e.capacity_block_extension_arn,
5724        }
5725    }
5726}
5727
5728impl From<&CapacityReservationFleet> for CapacityReservationFleetView {
5729    fn from(f: &CapacityReservationFleet) -> Self {
5730        CapacityReservationFleetView {
5731            capacity_reservation_fleet_id: f.capacity_reservation_fleet_id.clone(),
5732            capacity_reservation_fleet_arn: f.capacity_reservation_fleet_arn.clone(),
5733            state: f.state.clone(),
5734            tenancy: f.tenancy.clone(),
5735            allocation_strategy: f.allocation_strategy.clone(),
5736            instance_match_criteria: f.instance_match_criteria.clone(),
5737            total_target_capacity: f.total_target_capacity,
5738            total_fulfilled_capacity: f.total_fulfilled_capacity,
5739            create_time: f.create_time.clone(),
5740            end_date: f.end_date.clone(),
5741            instance_type_specifications: f
5742                .instance_type_specifications
5743                .iter()
5744                .map(CapacityReservationFleetInstanceSpecView::from)
5745                .collect(),
5746            tags: f.tags.clone(),
5747        }
5748    }
5749}
5750
5751impl From<&CapacityReservationFleetInstanceSpec> for CapacityReservationFleetInstanceSpecView {
5752    fn from(s: &CapacityReservationFleetInstanceSpec) -> Self {
5753        CapacityReservationFleetInstanceSpecView {
5754            instance_type: s.instance_type.clone(),
5755            instance_platform: s.instance_platform.clone(),
5756            availability_zone: s.availability_zone.clone(),
5757            ebs_optimized: s.ebs_optimized,
5758            priority: s.priority,
5759            weight: s.weight,
5760        }
5761    }
5762}
5763
5764impl From<&InstanceConnectEndpoint> for InstanceConnectEndpointView {
5765    fn from(i: &InstanceConnectEndpoint) -> Self {
5766        InstanceConnectEndpointView {
5767            instance_connect_endpoint_id: i.instance_connect_endpoint_id.clone(),
5768            instance_connect_endpoint_arn: i.instance_connect_endpoint_arn.clone(),
5769            subnet_id: i.subnet_id.clone(),
5770            vpc_id: i.vpc_id.clone(),
5771            availability_zone: i.availability_zone.clone(),
5772            state: i.state.clone(),
5773            created_at: i.created_at.clone(),
5774            preserve_client_ip: i.preserve_client_ip,
5775            security_group_ids: i.security_group_ids.clone(),
5776            network_interface_ids: i.network_interface_ids.clone(),
5777            dns_name: i.dns_name.clone(),
5778            fips_dns_name: i.fips_dns_name.clone(),
5779            ip_address_type: i.ip_address_type.clone(),
5780            owner_id: i.owner_id.clone(),
5781            tags: i.tags.clone(),
5782        }
5783    }
5784}
5785
5786// ---------------------------------------------------------------------------
5787// From view types to internal types
5788// ---------------------------------------------------------------------------
5789
5790impl From<Ec2StateView> for Ec2State {
5791    fn from(view: Ec2StateView) -> Self {
5792        Ec2State {
5793            vpcs: view
5794                .vpcs
5795                .into_iter()
5796                .map(|(k, v)| (k, Vpc::from(v)))
5797                .collect(),
5798            subnets: view
5799                .subnets
5800                .into_iter()
5801                .map(|(k, v)| (k, Subnet::from(v)))
5802                .collect(),
5803            igws: view
5804                .igws
5805                .into_iter()
5806                .map(|(k, v)| (k, InternetGateway::from(v)))
5807                .collect(),
5808            security_groups: view
5809                .security_groups
5810                .into_iter()
5811                .map(|(k, v)| (k, SecurityGroup::from(v)))
5812                .collect(),
5813            route_tables: view
5814                .route_tables
5815                .into_iter()
5816                .map(|(k, v)| (k, RouteTable::from(v)))
5817                .collect(),
5818            key_pairs: view
5819                .key_pairs
5820                .into_iter()
5821                .map(|(k, v)| (k, KeyPair::from(v)))
5822                .collect(),
5823            network_acls: view
5824                .network_acls
5825                .into_iter()
5826                .map(|(k, v)| (k, NetworkAcl::from(v)))
5827                .collect(),
5828            elastic_ips: view
5829                .elastic_ips
5830                .into_iter()
5831                .map(|(k, v)| (k, ElasticIp::from(v)))
5832                .collect(),
5833            nat_gateways: view
5834                .nat_gateways
5835                .into_iter()
5836                .map(|(k, v)| (k, NatGateway::from(v)))
5837                .collect(),
5838            dhcp_options: view
5839                .dhcp_options
5840                .into_iter()
5841                .map(|(k, v)| (k, DhcpOptions::from(v)))
5842                .collect(),
5843            egress_only_igws: view
5844                .egress_only_igws
5845                .into_iter()
5846                .map(|(k, v)| (k, EgressOnlyInternetGateway::from(v)))
5847                .collect(),
5848            flow_logs: view
5849                .flow_logs
5850                .into_iter()
5851                .map(|(k, v)| (k, FlowLog::from(v)))
5852                .collect(),
5853            vpc_peering_connections: view
5854                .vpc_peering_connections
5855                .into_iter()
5856                .map(|(k, v)| (k, VpcPeeringConnection::from(v)))
5857                .collect(),
5858            vpc_endpoints: view
5859                .vpc_endpoints
5860                .into_iter()
5861                .map(|(k, v)| (k, VpcEndpoint::from(v)))
5862                .collect(),
5863            managed_prefix_lists: view
5864                .managed_prefix_lists
5865                .into_iter()
5866                .map(|(k, v)| (k, ManagedPrefixList::from(v)))
5867                .collect(),
5868            customer_gateways: view
5869                .customer_gateways
5870                .into_iter()
5871                .map(|(k, v)| (k, CustomerGateway::from(v)))
5872                .collect(),
5873            vpn_gateways: view
5874                .vpn_gateways
5875                .into_iter()
5876                .map(|(k, v)| (k, VpnGateway::from(v)))
5877                .collect(),
5878            vpn_connections: view
5879                .vpn_connections
5880                .into_iter()
5881                .map(|(k, v)| (k, VpnConnection::from(v)))
5882                .collect(),
5883            carrier_gateways: view
5884                .carrier_gateways
5885                .into_iter()
5886                .map(|(k, v)| (k, CarrierGateway::from(v)))
5887                .collect(),
5888            network_interfaces: view
5889                .network_interfaces
5890                .into_iter()
5891                .map(|(k, v)| (k, NetworkInterface::from(v)))
5892                .collect(),
5893            vpc_cidr_associations: view.vpc_cidr_associations,
5894            ebs_encryption_by_default: view.ebs_encryption_by_default,
5895            transit_gateways: view
5896                .transit_gateways
5897                .into_iter()
5898                .map(|(k, v)| (k, TransitGateway::from(v)))
5899                .collect(),
5900            tgw_vpc_attachments: view
5901                .tgw_vpc_attachments
5902                .into_iter()
5903                .map(|(k, v)| (k, TransitGatewayVpcAttachment::from(v)))
5904                .collect(),
5905            tgw_peering_attachments: view
5906                .tgw_peering_attachments
5907                .into_iter()
5908                .map(|(k, v)| (k, TransitGatewayPeeringAttachment::from(v)))
5909                .collect(),
5910            tgw_route_tables: view
5911                .tgw_route_tables
5912                .into_iter()
5913                .map(|(k, v)| (k, TransitGatewayRouteTable::from(v)))
5914                .collect(),
5915            tgw_routes: view
5916                .tgw_routes
5917                .into_iter()
5918                .map(|(k, v)| (k, v.into_iter().map(TransitGatewayRoute::from).collect()))
5919                .collect(),
5920            instances: view
5921                .instances
5922                .into_iter()
5923                .map(|(k, v)| (k, Instance::from(v)))
5924                .collect(),
5925            volumes: view
5926                .volumes
5927                .into_iter()
5928                .map(|(k, v)| (k, Volume::from(v)))
5929                .collect(),
5930            snapshots: view
5931                .snapshots
5932                .into_iter()
5933                .map(|(k, v)| (k, Snapshot::from(v)))
5934                .collect(),
5935            images: view
5936                .images
5937                .into_iter()
5938                .map(|(k, v)| (k, Image::from(v)))
5939                .collect(),
5940            launch_templates: view
5941                .launch_templates
5942                .into_iter()
5943                .map(|(k, v)| (k, LaunchTemplate::from(v)))
5944                .collect(),
5945            launch_template_versions: view
5946                .launch_template_versions
5947                .into_iter()
5948                .map(|(k, v)| (k, v.into_iter().map(LaunchTemplateVersion::from).collect()))
5949                .collect(),
5950            spot_requests: view
5951                .spot_requests
5952                .into_iter()
5953                .map(|(k, v)| (k, SpotInstanceRequest::from(v)))
5954                .collect(),
5955            spot_datafeed_subscription: view
5956                .spot_datafeed_subscription
5957                .map(crate::types::SpotDatafeedSubscription::from),
5958            iam_instance_profile_associations: view
5959                .iam_instance_profile_associations
5960                .into_iter()
5961                .map(|(k, v)| (k, IamInstanceProfileAssociation::from(v)))
5962                .collect(),
5963            dedicated_hosts: view
5964                .dedicated_hosts
5965                .into_iter()
5966                .map(|(k, v)| (k, DedicatedHost::from(v)))
5967                .collect(),
5968            ec2_fleets: view
5969                .ec2_fleets
5970                .into_iter()
5971                .map(|(k, v)| (k, Ec2Fleet::from(v)))
5972                .collect(),
5973            vpc_endpoint_service_configs: view
5974                .vpc_endpoint_service_configs
5975                .into_iter()
5976                .map(|(k, v)| (k, VpcEndpointServiceConfiguration::from(v)))
5977                .collect(),
5978            spot_fleet_requests: view
5979                .spot_fleet_requests
5980                .into_iter()
5981                .map(|(k, v)| (k, SpotFleetRequest::from(v)))
5982                .collect(),
5983            subnet_cidr_reservations: view
5984                .subnet_cidr_reservations
5985                .into_iter()
5986                .map(|(k, v)| (k, SubnetCidrReservationEntry::from(v)))
5987                .collect(),
5988            placement_groups: view
5989                .placement_groups
5990                .into_iter()
5991                .map(|(k, v)| (k, PlacementGroup::from(v)))
5992                .collect(),
5993            network_interface_permissions: view
5994                .network_interface_permissions
5995                .into_iter()
5996                .map(|(k, v)| (k, NetworkInterfacePermission::from(v)))
5997                .collect(),
5998            instance_connect_endpoints: view
5999                .instance_connect_endpoints
6000                .into_iter()
6001                .map(|(k, v)| (k, InstanceConnectEndpoint::from(v)))
6002                .collect(),
6003            capacity_reservations: view
6004                .capacity_reservations
6005                .into_iter()
6006                .map(|(k, v)| (k, CapacityReservation::from(v)))
6007                .collect(),
6008            capacity_reservation_fleets: view
6009                .capacity_reservation_fleets
6010                .into_iter()
6011                .map(|(k, v)| (k, CapacityReservationFleet::from(v)))
6012                .collect(),
6013            coip_pools: view
6014                .coip_pools
6015                .into_iter()
6016                .map(|(k, v)| (k, CoipPool::from(v)))
6017                .collect(),
6018            byoip_cidrs: view
6019                .byoip_cidrs
6020                .into_iter()
6021                .map(|(k, v)| (k, ByoipCidr::from(v)))
6022                .collect(),
6023            public_ipv4_pools: view
6024                .public_ipv4_pools
6025                .into_iter()
6026                .map(|(k, v)| (k, PublicIpv4Pool::from(v)))
6027                .collect(),
6028            coip_cidrs: view
6029                .coip_cidrs
6030                .into_iter()
6031                .map(|v| ((v.cidr.clone(), v.coip_pool_id.clone()), CoipCidr::from(v)))
6032                .collect(),
6033            address_transfers: view
6034                .address_transfers
6035                .into_iter()
6036                .map(|(k, v)| (k, AddressTransfer::from(v)))
6037                .collect(),
6038            security_group_vpc_associations: view
6039                .security_group_vpc_associations
6040                .into_iter()
6041                .map(|v| {
6042                    (
6043                        (v.group_id.clone(), v.vpc_id.clone()),
6044                        SecurityGroupVpcAssociation::from(v),
6045                    )
6046                })
6047                .collect(),
6048            enclave_certificate_iam_role_associations: view
6049                .enclave_certificate_iam_role_associations
6050                .into_iter()
6051                .map(|v| {
6052                    (
6053                        (v.certificate_arn.clone(), v.role_arn.clone()),
6054                        EnclaveCertificateIamRoleAssociation::from(v),
6055                    )
6056                })
6057                .collect(),
6058            mac_sip_modification_tasks: view
6059                .mac_sip_modification_tasks
6060                .into_iter()
6061                .map(|(k, v)| (k, MacSipModificationTask::from(v)))
6062                .collect(),
6063            declarative_policies_reports: view
6064                .declarative_policies_reports
6065                .into_iter()
6066                .map(|(k, v)| (k, DeclarativePoliciesReport::from(v)))
6067                .collect(),
6068            vpn_concentrators: view
6069                .vpn_concentrators
6070                .into_iter()
6071                .map(|(k, v)| (k, VpnConcentrator::from(v)))
6072                .collect(),
6073            vpc_endpoint_connections: view
6074                .vpc_endpoint_connections
6075                .into_iter()
6076                .map(|v| {
6077                    let key = (v.service_id.clone(), v.vpc_endpoint_id.clone());
6078                    (key, VpcEndpointConnection::from(v))
6079                })
6080                .collect(),
6081            vpc_endpoint_connection_notifications: view
6082                .vpc_endpoint_connection_notifications
6083                .into_iter()
6084                .map(|(k, v)| (k, VpcEndpointConnectionNotification::from(v)))
6085                .collect(),
6086            vpc_block_public_access_exclusions: view
6087                .vpc_block_public_access_exclusions
6088                .into_iter()
6089                .map(|(k, v)| (k, VpcBlockPublicAccessExclusion::from(v)))
6090                .collect(),
6091            vpc_block_public_access_options: view
6092                .vpc_block_public_access_options
6093                .map(VpcBlockPublicAccessOptions::from),
6094            vpc_encryption_controls: view
6095                .vpc_encryption_controls
6096                .into_iter()
6097                .map(|(k, v)| (k, VpcEncryptionControl::from(v)))
6098                .collect(),
6099            mac_volume_ownership_tasks: view
6100                .mac_volume_ownership_tasks
6101                .into_iter()
6102                .map(|(k, v)| (k, MacVolumeOwnershipTask::from(v)))
6103                .collect(),
6104            replace_root_volume_tasks: view
6105                .replace_root_volume_tasks
6106                .into_iter()
6107                .map(|(k, v)| (k, ReplaceRootVolumeTask::from(v)))
6108                .collect(),
6109            snapshot_import_tasks: view
6110                .snapshot_import_tasks
6111                .into_iter()
6112                .map(|(k, v)| (k, SnapshotImportTask::from(v)))
6113                .collect(),
6114            conversion_tasks: view
6115                .conversion_tasks
6116                .into_iter()
6117                .map(|(k, v)| (k, ConversionTask::from(v)))
6118                .collect(),
6119            export_tasks: view
6120                .export_tasks
6121                .into_iter()
6122                .map(|(k, v)| (k, ExportTask::from(v)))
6123                .collect(),
6124            import_tasks: view.import_tasks,
6125            trunk_interface_associations: view
6126                .trunk_interface_associations
6127                .into_iter()
6128                .map(|(k, v)| (k, TrunkInterfaceAssociation::from(v)))
6129                .collect(),
6130            secondary_networks: view
6131                .secondary_networks
6132                .into_iter()
6133                .map(|(k, v)| (k, SecondaryNetwork::from(v)))
6134                .collect(),
6135            secondary_subnets: view
6136                .secondary_subnets
6137                .into_iter()
6138                .map(|(k, v)| (k, SecondarySubnet::from(v)))
6139                .collect(),
6140            deleted_volumes_recycle_bin: view
6141                .deleted_volumes_recycle_bin
6142                .into_iter()
6143                .map(|(k, v)| (k, Volume::from(v)))
6144                .collect(),
6145            deleted_snapshots_recycle_bin: view
6146                .deleted_snapshots_recycle_bin
6147                .into_iter()
6148                .map(|(k, v)| (k, Snapshot::from(v)))
6149                .collect(),
6150            reserved_instances_exchanges: view
6151                .reserved_instances_exchanges
6152                .into_iter()
6153                .map(|(k, v)| (k, crate::types::ReservedInstancesExchange::from(v)))
6154                .collect(),
6155            reserved_instances_listings: view
6156                .reserved_instances_listings
6157                .into_iter()
6158                .map(|(k, v)| (k, crate::types::ReservedInstancesListing::from(v)))
6159                .collect(),
6160            queued_reserved_instances_purchases: view
6161                .queued_reserved_instances_purchases
6162                .into_iter()
6163                .map(|(k, v)| (k, crate::types::ReservedInstancesPurchase::from(v)))
6164                .collect(),
6165            reserved_instances_modifications: view
6166                .reserved_instances_modifications
6167                .into_iter()
6168                .map(|(k, v)| (k, crate::types::ReservedInstancesModification::from(v)))
6169                .collect(),
6170            reserved_instances_purchases: view
6171                .reserved_instances_purchases
6172                .into_iter()
6173                .map(|(k, v)| (k, crate::types::ReservedInstancesPurchase::from(v)))
6174                .collect(),
6175            reserved_instances: view
6176                .reserved_instances
6177                .into_iter()
6178                .map(|(k, v)| (k, crate::types::ReservedInstances::from(v)))
6179                .collect(),
6180            fpga_images: view
6181                .fpga_images
6182                .into_iter()
6183                .map(|(k, v)| (k, crate::types::FpgaImage::from(v)))
6184                .collect(),
6185            image_usage_reports: view
6186                .image_usage_reports
6187                .into_iter()
6188                .map(|(k, v)| (k, crate::types::ImageUsageReport::from(v)))
6189                .collect(),
6190            restore_image_tasks: view
6191                .restore_image_tasks
6192                .into_iter()
6193                .map(|(k, v)| (k, crate::types::RestoreImageTask::from(v)))
6194                .collect(),
6195            store_image_tasks: view
6196                .store_image_tasks
6197                .into_iter()
6198                .map(|(k, v)| (k, crate::types::StoreImageTask::from(v)))
6199                .collect(),
6200            import_image_tasks: view
6201                .import_image_tasks
6202                .into_iter()
6203                .map(|(k, v)| (k, crate::types::ImportImageTask::from(v)))
6204                .collect(),
6205            allowed_image_criteria: view
6206                .allowed_image_criteria
6207                .into_iter()
6208                .map(crate::types::AllowedImageCriterion::from)
6209                .collect(),
6210            default_credit_specifications: view.default_credit_specifications,
6211            instance_metadata_defaults: view
6212                .instance_metadata_defaults
6213                .map(crate::types::InstanceMetadataDefaults::from),
6214            instance_event_windows: view
6215                .instance_event_windows
6216                .into_iter()
6217                .map(|(k, v)| (k, crate::types::InstanceEventWindow::from(v)))
6218                .collect(),
6219            instance_event_notification_attributes: view
6220                .instance_event_notification_attributes
6221                .map(crate::types::InstanceTagNotificationAttributes::from),
6222            instance_events: view
6223                .instance_events
6224                .into_iter()
6225                .map(|(k, v)| (k, crate::types::InstanceEvent::from(v)))
6226                .collect(),
6227            host_reservations: view
6228                .host_reservations
6229                .into_iter()
6230                .map(|(k, v)| (k, crate::types::HostReservation::from(v)))
6231                .collect(),
6232            scheduled_instances: view
6233                .scheduled_instances
6234                .into_iter()
6235                .map(|(k, v)| (k, crate::types::ScheduledInstance::from(v)))
6236                .collect(),
6237            az_group_opt_in: view.az_group_opt_in,
6238            instance_status_reports: view
6239                .instance_status_reports
6240                .into_iter()
6241                .map(crate::types::InstanceStatusReport::from)
6242                .collect(),
6243            network_insights_access_scopes: view
6244                .network_insights_access_scopes
6245                .into_iter()
6246                .map(|(k, v)| (k, NetworkInsightsAccessScope::from(v)))
6247                .collect(),
6248            network_insights_access_scope_analyses: view
6249                .network_insights_access_scope_analyses
6250                .into_iter()
6251                .map(|(k, v)| (k, NetworkInsightsAccessScopeAnalysis::from(v)))
6252                .collect(),
6253            network_insights_paths: view
6254                .network_insights_paths
6255                .into_iter()
6256                .map(|(k, v)| (k, NetworkInsightsPath::from(v)))
6257                .collect(),
6258            network_insights_analyses: view
6259                .network_insights_analyses
6260                .into_iter()
6261                .map(|(k, v)| (k, NetworkInsightsAnalysis::from(v)))
6262                .collect(),
6263            traffic_mirror_filters: view
6264                .traffic_mirror_filters
6265                .into_iter()
6266                .map(|(k, v)| (k, TrafficMirrorFilter::from(v)))
6267                .collect(),
6268            traffic_mirror_sessions: view
6269                .traffic_mirror_sessions
6270                .into_iter()
6271                .map(|(k, v)| (k, TrafficMirrorSession::from(v)))
6272                .collect(),
6273            traffic_mirror_targets: view
6274                .traffic_mirror_targets
6275                .into_iter()
6276                .map(|(k, v)| (k, TrafficMirrorTarget::from(v)))
6277                .collect(),
6278            client_vpn_endpoints: view
6279                .client_vpn_endpoints
6280                .into_iter()
6281                .map(|(k, v)| (k, ClientVpnEndpoint::from(v)))
6282                .collect(),
6283            client_vpn_target_network_associations: view
6284                .client_vpn_target_network_associations
6285                .into_iter()
6286                .map(|(k, v)| (k, ClientVpnTargetNetworkAssociation::from(v)))
6287                .collect(),
6288            client_vpn_authorization_rules: view
6289                .client_vpn_authorization_rules
6290                .into_iter()
6291                .map(|v| {
6292                    let key = (
6293                        v.client_vpn_endpoint_id.clone(),
6294                        v.destination_cidr.clone(),
6295                        v.group_id.clone().unwrap_or_default(),
6296                    );
6297                    (key, ClientVpnAuthorizationRule::from(v))
6298                })
6299                .collect(),
6300            client_vpn_routes: view
6301                .client_vpn_routes
6302                .into_iter()
6303                .map(|v| {
6304                    let key = (
6305                        v.client_vpn_endpoint_id.clone(),
6306                        v.destination_cidr.clone(),
6307                        v.target_subnet.clone(),
6308                    );
6309                    (key, ClientVpnRoute::from(v))
6310                })
6311                .collect(),
6312            client_vpn_connections: view
6313                .client_vpn_connections
6314                .into_iter()
6315                .map(|(k, v)| (k, ClientVpnConnection::from(v)))
6316                .collect(),
6317            local_gateways: view
6318                .local_gateways
6319                .into_iter()
6320                .map(|(k, v)| (k, LocalGateway::from(v)))
6321                .collect(),
6322            local_gateway_route_tables: view
6323                .local_gateway_route_tables
6324                .into_iter()
6325                .map(|(k, v)| (k, LocalGatewayRouteTable::from(v)))
6326                .collect(),
6327            local_gateway_routes: view
6328                .local_gateway_routes
6329                .into_iter()
6330                .map(|v| {
6331                    let key = (
6332                        v.local_gateway_route_table_id.clone(),
6333                        v.destination_cidr_block.clone(),
6334                    );
6335                    (key, LocalGatewayRoute::from(v))
6336                })
6337                .collect(),
6338            local_gateway_route_table_virtual_interface_group_associations: view
6339                .local_gateway_route_table_virtual_interface_group_associations
6340                .into_iter()
6341                .map(|(k, v)| {
6342                    (
6343                        k,
6344                        LocalGatewayRouteTableVirtualInterfaceGroupAssociation::from(v),
6345                    )
6346                })
6347                .collect(),
6348            local_gateway_route_table_vpc_associations: view
6349                .local_gateway_route_table_vpc_associations
6350                .into_iter()
6351                .map(|(k, v)| (k, LocalGatewayRouteTableVpcAssociation::from(v)))
6352                .collect(),
6353            local_gateway_virtual_interfaces: view
6354                .local_gateway_virtual_interfaces
6355                .into_iter()
6356                .map(|(k, v)| (k, LocalGatewayVirtualInterface::from(v)))
6357                .collect(),
6358            local_gateway_virtual_interface_groups: view
6359                .local_gateway_virtual_interface_groups
6360                .into_iter()
6361                .map(|(k, v)| (k, LocalGatewayVirtualInterfaceGroup::from(v)))
6362                .collect(),
6363            route_servers: view
6364                .route_servers
6365                .into_iter()
6366                .map(|(k, v)| (k, RouteServer::from(v)))
6367                .collect(),
6368            route_server_endpoints: view
6369                .route_server_endpoints
6370                .into_iter()
6371                .map(|(k, v)| (k, RouteServerEndpoint::from(v)))
6372                .collect(),
6373            route_server_peers: view
6374                .route_server_peers
6375                .into_iter()
6376                .map(|(k, v)| (k, RouteServerPeer::from(v)))
6377                .collect(),
6378            route_server_associations: view
6379                .route_server_associations
6380                .into_iter()
6381                .map(|v| {
6382                    let key = (v.route_server_id.clone(), v.vpc_id.clone());
6383                    (key, RouteServerAssociation::from(v))
6384                })
6385                .collect(),
6386            verified_access_instances: view
6387                .verified_access_instances
6388                .into_iter()
6389                .map(|(k, v)| (k, VerifiedAccessInstance::from(v)))
6390                .collect(),
6391            verified_access_trust_providers: view
6392                .verified_access_trust_providers
6393                .into_iter()
6394                .map(|(k, v)| (k, VerifiedAccessTrustProvider::from(v)))
6395                .collect(),
6396            verified_access_groups: view
6397                .verified_access_groups
6398                .into_iter()
6399                .map(|(k, v)| (k, VerifiedAccessGroup::from(v)))
6400                .collect(),
6401            verified_access_endpoints: view
6402                .verified_access_endpoints
6403                .into_iter()
6404                .map(|(k, v)| (k, VerifiedAccessEndpoint::from(v)))
6405                .collect(),
6406            verified_access_trust_provider_attachments: view
6407                .verified_access_trust_provider_attachments
6408                .into_iter()
6409                .map(|v| {
6410                    let key = (v.instance_id.clone(), v.trust_provider_id.clone());
6411                    (key, VerifiedAccessTrustProviderAttachment::from(v))
6412                })
6413                .collect(),
6414            verified_access_instance_logging_configurations: view
6415                .verified_access_instance_logging_configurations
6416                .into_iter()
6417                .map(|(k, v)| (k, VerifiedAccessLogs::from(v)))
6418                .collect(),
6419            billing_ownership_offers: view
6420                .billing_ownership_offers
6421                .into_iter()
6422                .map(|o| {
6423                    let key = (
6424                        o.capacity_reservation_id.clone(),
6425                        o.unused_reservation_billing_owner_id.clone(),
6426                    );
6427                    (key, BillingOwnershipOffer::from(o))
6428                })
6429                .collect(),
6430            capacity_manager_data_exports: view
6431                .capacity_manager_data_exports
6432                .into_iter()
6433                .map(|(k, v)| (k, CapacityManagerDataExport::from(v)))
6434                .collect(),
6435            interruptible_capacity_reservation_allocations: view
6436                .interruptible_capacity_reservation_allocations
6437                .into_iter()
6438                .map(|(k, v)| (k, InterruptibleCapacityReservationAllocation::from(v)))
6439                .collect(),
6440            capacity_blocks: view
6441                .capacity_blocks
6442                .into_iter()
6443                .map(|(k, v)| (k, CapacityBlock::from(v)))
6444                .collect(),
6445            capacity_block_extensions: view
6446                .capacity_block_extensions
6447                .into_iter()
6448                .map(|(k, v)| (k, CapacityBlockExtension::from(v)))
6449                .collect(),
6450            capacity_manager_organizations_access: view
6451                .capacity_manager_organizations_access
6452                .map(CapacityManagerOrganizationsAccess::from),
6453            tgw_multicast_domains: view
6454                .tgw_multicast_domains
6455                .into_iter()
6456                .map(|(k, v)| (k, TransitGatewayMulticastDomain::from(v)))
6457                .collect(),
6458            tgw_multicast_domain_associations: view
6459                .tgw_multicast_domain_associations
6460                .into_iter()
6461                .map(|v| {
6462                    let key = (
6463                        v.transit_gateway_multicast_domain_id.clone(),
6464                        v.transit_gateway_attachment_id.clone(),
6465                    );
6466                    (key, TransitGatewayMulticastDomainAssociation::from(v))
6467                })
6468                .collect(),
6469            tgw_multicast_group_members: view
6470                .tgw_multicast_group_members
6471                .into_iter()
6472                .map(|v| {
6473                    let key = (
6474                        v.transit_gateway_multicast_domain_id.clone(),
6475                        v.group_ip_address.clone(),
6476                        v.network_interface_id.clone(),
6477                    );
6478                    (key, TransitGatewayMulticastGroupMember::from(v))
6479                })
6480                .collect(),
6481            tgw_multicast_group_sources: view
6482                .tgw_multicast_group_sources
6483                .into_iter()
6484                .map(|v| {
6485                    let key = (
6486                        v.transit_gateway_multicast_domain_id.clone(),
6487                        v.group_ip_address.clone(),
6488                        v.network_interface_id.clone(),
6489                    );
6490                    (key, TransitGatewayMulticastGroupSource::from(v))
6491                })
6492                .collect(),
6493            tgw_connects: view
6494                .tgw_connects
6495                .into_iter()
6496                .map(|(k, v)| (k, TransitGatewayConnect::from(v)))
6497                .collect(),
6498            tgw_connect_peers: view
6499                .tgw_connect_peers
6500                .into_iter()
6501                .map(|(k, v)| (k, TransitGatewayConnectPeer::from(v)))
6502                .collect(),
6503            tgw_metering_policies: view
6504                .tgw_metering_policies
6505                .into_iter()
6506                .map(|(k, v)| (k, TransitGatewayMeteringPolicy::from(v)))
6507                .collect(),
6508            tgw_metering_policy_entries: view
6509                .tgw_metering_policy_entries
6510                .into_iter()
6511                .map(|v| {
6512                    let key = (
6513                        v.transit_gateway_metering_policy_id.clone(),
6514                        v.transit_gateway_metering_policy_entry_id.clone(),
6515                    );
6516                    (key, TransitGatewayMeteringPolicyEntry::from(v))
6517                })
6518                .collect(),
6519            tgw_policy_tables: view
6520                .tgw_policy_tables
6521                .into_iter()
6522                .map(|(k, v)| (k, TransitGatewayPolicyTable::from(v)))
6523                .collect(),
6524            tgw_policy_table_associations: view
6525                .tgw_policy_table_associations
6526                .into_iter()
6527                .map(|v| {
6528                    let key = (
6529                        v.transit_gateway_policy_table_id.clone(),
6530                        v.transit_gateway_attachment_id.clone(),
6531                    );
6532                    (key, TransitGatewayPolicyTableAssociation::from(v))
6533                })
6534                .collect(),
6535            tgw_prefix_list_references: view
6536                .tgw_prefix_list_references
6537                .into_iter()
6538                .map(|v| {
6539                    let key = (
6540                        v.transit_gateway_route_table_id.clone(),
6541                        v.prefix_list_id.clone(),
6542                    );
6543                    (key, TransitGatewayPrefixListReference::from(v))
6544                })
6545                .collect(),
6546            tgw_route_table_announcements: view
6547                .tgw_route_table_announcements
6548                .into_iter()
6549                .map(|(k, v)| (k, TransitGatewayRouteTableAnnouncement::from(v)))
6550                .collect(),
6551            ipams: view
6552                .ipams
6553                .into_iter()
6554                .map(|(k, v)| (k, Ipam::from(v)))
6555                .collect(),
6556            ipam_scopes: view
6557                .ipam_scopes
6558                .into_iter()
6559                .map(|(k, v)| (k, IpamScope::from(v)))
6560                .collect(),
6561            ipam_pools: view
6562                .ipam_pools
6563                .into_iter()
6564                .map(|(k, v)| (k, IpamPool::from(v)))
6565                .collect(),
6566            ipam_pool_cidrs: view
6567                .ipam_pool_cidrs
6568                .into_iter()
6569                .map(|v| {
6570                    let key = (v.ipam_pool_id.clone(), v.cidr.clone());
6571                    (key, IpamPoolCidr::from(v))
6572                })
6573                .collect(),
6574            ipam_pool_allocations: view
6575                .ipam_pool_allocations
6576                .into_iter()
6577                .map(|v| {
6578                    let key = (v.ipam_pool_id.clone(), v.ipam_pool_allocation_id.clone());
6579                    (key, IpamPoolAllocation::from(v))
6580                })
6581                .collect(),
6582            ipam_resource_discoveries: view
6583                .ipam_resource_discoveries
6584                .into_iter()
6585                .map(|(k, v)| (k, IpamResourceDiscovery::from(v)))
6586                .collect(),
6587            ipam_resource_discovery_associations: view
6588                .ipam_resource_discovery_associations
6589                .into_iter()
6590                .map(|(k, v)| (k, IpamResourceDiscoveryAssociation::from(v)))
6591                .collect(),
6592            ipam_byoasns: view
6593                .ipam_byoasns
6594                .into_iter()
6595                .map(|v| {
6596                    let key = (v.ipam_id.clone(), v.asn.clone());
6597                    (key, IpamByoasn::from(v))
6598                })
6599                .collect(),
6600            ipam_external_resource_verification_tokens: view
6601                .ipam_external_resource_verification_tokens
6602                .into_iter()
6603                .map(|(k, v)| (k, IpamExternalResourceVerificationToken::from(v)))
6604                .collect(),
6605            ipam_policies: view
6606                .ipam_policies
6607                .into_iter()
6608                .map(|(k, v)| (k, IpamPolicy::from(v)))
6609                .collect(),
6610            ipam_prefix_list_resolvers: view
6611                .ipam_prefix_list_resolvers
6612                .into_iter()
6613                .map(|(k, v)| (k, IpamPrefixListResolver::from(v)))
6614                .collect(),
6615            ipam_prefix_list_resolver_targets: view
6616                .ipam_prefix_list_resolver_targets
6617                .into_iter()
6618                .map(|v| {
6619                    let key = (
6620                        v.ipam_prefix_list_resolver_id.clone(),
6621                        v.ipam_prefix_list_resolver_target_id.clone(),
6622                    );
6623                    (key, IpamPrefixListResolverTarget::from(v))
6624                })
6625                .collect(),
6626            volume_modifications: view
6627                .volume_modifications
6628                .into_iter()
6629                .map(|(k, v)| (k, crate::types::VolumeModification::from(v)))
6630                .collect(),
6631            import_volume_tasks: view
6632                .import_volume_tasks
6633                .into_iter()
6634                .map(|(k, v)| (k, crate::types::ImportVolumeTask::from(v)))
6635                .collect(),
6636            bundle_tasks: view
6637                .bundle_tasks
6638                .into_iter()
6639                .map(|(k, v)| (k, crate::types::BundleTask::from(v)))
6640                .collect(),
6641            id_format: view
6642                .id_format
6643                .into_iter()
6644                .map(|(k, v)| (k, crate::types::IdFormatEntry::from(v)))
6645                .collect(),
6646            outpost_lags: view
6647                .outpost_lags
6648                .into_iter()
6649                .map(|(k, v)| (k, crate::types::OutpostLag::from(v)))
6650                .collect(),
6651            export_image_tasks: view
6652                .export_image_tasks
6653                .into_iter()
6654                .map(|(k, v)| (k, crate::types::ExportImageTask::from(v)))
6655                .collect(),
6656            ebs_default_kms_key_id: view.ebs_default_kms_key_id,
6657            serial_console_access_enabled: view.serial_console_access_enabled,
6658            allowed_images_settings_state: view.allowed_images_settings_state,
6659            image_block_public_access_state: view.image_block_public_access_state,
6660            aws_network_performance_subscriptions: view
6661                .aws_network_performance_subscriptions
6662                .into_iter()
6663                .map(|s| {
6664                    let key = (
6665                        s.source.clone(),
6666                        s.destination.clone(),
6667                        s.metric.clone(),
6668                        s.statistic.clone(),
6669                    );
6670                    (
6671                        key,
6672                        crate::types::AwsNetworkPerformanceSubscription {
6673                            source: s.source,
6674                            destination: s.destination,
6675                            metric: s.metric,
6676                            statistic: s.statistic,
6677                            period: s.period,
6678                        },
6679                    )
6680                })
6681                .collect(),
6682            counters: crate::state::Ec2Counters::from(view.counters),
6683            deregistered_images: Default::default(),
6684        }
6685    }
6686}
6687
6688impl From<VpcView> for Vpc {
6689    fn from(v: VpcView) -> Self {
6690        Vpc {
6691            vpc_id: v.vpc_id,
6692            cidr_block: v.cidr_block,
6693            state: v.state,
6694            dhcp_options_id: v.dhcp_options_id,
6695            instance_tenancy: v.instance_tenancy,
6696            is_default: v.is_default,
6697            enable_dns_hostnames: v.enable_dns_hostnames,
6698            enable_dns_support: v.enable_dns_support,
6699            secondary_cidr_blocks: v.secondary_cidr_blocks,
6700            tags: v.tags,
6701            classic_link_enabled: v.classic_link_enabled,
6702        }
6703    }
6704}
6705
6706impl From<SubnetView> for Subnet {
6707    fn from(s: SubnetView) -> Self {
6708        Subnet {
6709            subnet_id: s.subnet_id,
6710            vpc_id: s.vpc_id,
6711            cidr_block: s.cidr_block,
6712            availability_zone: s.availability_zone,
6713            state: s.state,
6714            available_ip_address_count: s.available_ip_address_count,
6715            map_public_ip_on_launch: s.map_public_ip_on_launch,
6716            ipv6_cidr_blocks: s
6717                .ipv6_cidr_blocks
6718                .into_iter()
6719                .map(SubnetIpv6CidrAssoc::from)
6720                .collect(),
6721            tags: s.tags,
6722        }
6723    }
6724}
6725
6726impl From<SubnetIpv6CidrAssocView> for SubnetIpv6CidrAssoc {
6727    fn from(a: SubnetIpv6CidrAssocView) -> Self {
6728        SubnetIpv6CidrAssoc {
6729            association_id: a.association_id,
6730            ipv6_cidr_block: a.ipv6_cidr_block,
6731            state: a.state,
6732        }
6733    }
6734}
6735
6736impl From<InternetGatewayView> for InternetGateway {
6737    fn from(igw: InternetGatewayView) -> Self {
6738        InternetGateway {
6739            igw_id: igw.igw_id,
6740            attachments: igw
6741                .attachments
6742                .into_iter()
6743                .map(IgwAttachment::from)
6744                .collect(),
6745            tags: igw.tags,
6746        }
6747    }
6748}
6749
6750impl From<IgwAttachmentView> for IgwAttachment {
6751    fn from(a: IgwAttachmentView) -> Self {
6752        IgwAttachment {
6753            vpc_id: a.vpc_id,
6754            state: a.state,
6755        }
6756    }
6757}
6758
6759impl From<SecurityGroupView> for SecurityGroup {
6760    fn from(sg: SecurityGroupView) -> Self {
6761        SecurityGroup {
6762            group_id: sg.group_id,
6763            group_name: sg.group_name,
6764            description: sg.description,
6765            vpc_id: sg.vpc_id,
6766            owner_id: sg.owner_id,
6767            ingress_rules: sg
6768                .ingress_rules
6769                .into_iter()
6770                .map(IpPermission::from)
6771                .collect(),
6772            egress_rules: sg
6773                .egress_rules
6774                .into_iter()
6775                .map(IpPermission::from)
6776                .collect(),
6777            tags: sg.tags,
6778        }
6779    }
6780}
6781
6782impl From<IpPermissionView> for IpPermission {
6783    fn from(p: IpPermissionView) -> Self {
6784        IpPermission {
6785            rule_id: String::new(),
6786            from_port: p.from_port,
6787            to_port: p.to_port,
6788            ip_protocol: p.ip_protocol,
6789            ip_ranges: p.ip_ranges.into_iter().map(IpRange::from).collect(),
6790            ipv6_ranges: p.ipv6_ranges.into_iter().map(Ipv6Range::from).collect(),
6791            user_id_group_pairs: p
6792                .user_id_group_pairs
6793                .into_iter()
6794                .map(UserIdGroupPair::from)
6795                .collect(),
6796        }
6797    }
6798}
6799
6800impl From<IpRangeView> for IpRange {
6801    fn from(r: IpRangeView) -> Self {
6802        IpRange {
6803            cidr_ip: r.cidr_ip,
6804            description: r.description,
6805        }
6806    }
6807}
6808
6809impl From<Ipv6RangeView> for Ipv6Range {
6810    fn from(r: Ipv6RangeView) -> Self {
6811        Ipv6Range {
6812            cidr_ipv6: r.cidr_ipv6,
6813            description: r.description,
6814        }
6815    }
6816}
6817
6818impl From<UserIdGroupPairView> for UserIdGroupPair {
6819    fn from(p: UserIdGroupPairView) -> Self {
6820        UserIdGroupPair {
6821            group_id: p.group_id,
6822            user_id: p.user_id,
6823        }
6824    }
6825}
6826
6827impl From<RouteTableView> for RouteTable {
6828    fn from(rtb: RouteTableView) -> Self {
6829        RouteTable {
6830            route_table_id: rtb.route_table_id,
6831            vpc_id: rtb.vpc_id,
6832            routes: rtb.routes.into_iter().map(Route::from).collect(),
6833            associations: rtb
6834                .associations
6835                .into_iter()
6836                .map(RouteTableAssociation::from)
6837                .collect(),
6838            propagating_vgws: rtb.propagating_vgws,
6839            tags: rtb.tags,
6840        }
6841    }
6842}
6843
6844impl From<RouteView> for Route {
6845    fn from(r: RouteView) -> Self {
6846        Route {
6847            destination_cidr_block: r.destination_cidr_block,
6848            destination_ipv6_cidr_block: r.destination_ipv6_cidr_block,
6849            gateway_id: r.gateway_id,
6850            state: r.state,
6851            origin: r.origin,
6852        }
6853    }
6854}
6855
6856impl From<RouteTableAssociationView> for RouteTableAssociation {
6857    fn from(a: RouteTableAssociationView) -> Self {
6858        RouteTableAssociation {
6859            association_id: a.association_id,
6860            subnet_id: a.subnet_id,
6861            gateway_id: a.gateway_id,
6862            main: a.main,
6863            state: a.state,
6864        }
6865    }
6866}
6867
6868impl From<KeyPairView> for KeyPair {
6869    fn from(kp: KeyPairView) -> Self {
6870        KeyPair {
6871            key_pair_id: kp.key_pair_id,
6872            key_name: kp.key_name,
6873            fingerprint: kp.fingerprint,
6874            tags: kp.tags,
6875        }
6876    }
6877}
6878
6879impl From<NetworkAclView> for NetworkAcl {
6880    fn from(n: NetworkAclView) -> Self {
6881        NetworkAcl {
6882            network_acl_id: n.network_acl_id,
6883            vpc_id: n.vpc_id,
6884            is_default: n.is_default,
6885            entries: n.entries.into_iter().map(NetworkAclEntry::from).collect(),
6886            associations: n
6887                .associations
6888                .into_iter()
6889                .map(NetworkAclAssociation::from)
6890                .collect(),
6891            tags: n.tags,
6892        }
6893    }
6894}
6895
6896impl From<NetworkAclEntryView> for NetworkAclEntry {
6897    fn from(e: NetworkAclEntryView) -> Self {
6898        NetworkAclEntry {
6899            rule_number: e.rule_number,
6900            protocol: e.protocol,
6901            rule_action: e.rule_action,
6902            egress: e.egress,
6903            cidr_block: e.cidr_block,
6904            ipv6_cidr_block: e.ipv6_cidr_block,
6905            port_range: e.port_range.map(PortRange::from),
6906            icmp_type_code: e.icmp_type_code.map(IcmpTypeCode::from),
6907        }
6908    }
6909}
6910
6911impl From<PortRangeView> for PortRange {
6912    fn from(p: PortRangeView) -> Self {
6913        PortRange {
6914            from: p.from,
6915            to: p.to,
6916        }
6917    }
6918}
6919
6920impl From<IcmpTypeCodeView> for IcmpTypeCode {
6921    fn from(i: IcmpTypeCodeView) -> Self {
6922        IcmpTypeCode {
6923            type_num: i.type_num,
6924            code: i.code,
6925        }
6926    }
6927}
6928
6929impl From<NetworkAclAssociationView> for NetworkAclAssociation {
6930    fn from(a: NetworkAclAssociationView) -> Self {
6931        NetworkAclAssociation {
6932            network_acl_association_id: a.network_acl_association_id,
6933            network_acl_id: a.network_acl_id,
6934            subnet_id: a.subnet_id,
6935        }
6936    }
6937}
6938
6939impl From<ElasticIpView> for ElasticIp {
6940    fn from(e: ElasticIpView) -> Self {
6941        ElasticIp {
6942            allocation_id: e.allocation_id,
6943            public_ip: e.public_ip,
6944            association_id: e.association_id,
6945            instance_id: e.instance_id,
6946            network_interface_id: e.network_interface_id,
6947            private_ip_address: e.private_ip_address,
6948            address_attribute_ptr_record: e.address_attribute_ptr_record,
6949            domain: e.domain,
6950            pending_transfer: e.pending_transfer,
6951            tags: e.tags,
6952        }
6953    }
6954}
6955
6956impl From<NatGatewayView> for NatGateway {
6957    fn from(n: NatGatewayView) -> Self {
6958        NatGateway {
6959            nat_gateway_id: n.nat_gateway_id,
6960            vpc_id: n.vpc_id,
6961            subnet_id: n.subnet_id,
6962            state: n.state,
6963            connectivity_type: n.connectivity_type,
6964            allocation_id: n.allocation_id,
6965            public_ip: n.public_ip,
6966            secondary_addresses: n
6967                .secondary_addresses
6968                .into_iter()
6969                .map(NatGatewayAddressAssociation::from)
6970                .collect(),
6971            tags: n.tags,
6972        }
6973    }
6974}
6975
6976impl From<DhcpOptionsView> for DhcpOptions {
6977    fn from(d: DhcpOptionsView) -> Self {
6978        DhcpOptions {
6979            dhcp_options_id: d.dhcp_options_id,
6980            configurations: d
6981                .configurations
6982                .into_iter()
6983                .map(DhcpConfiguration::from)
6984                .collect(),
6985            tags: d.tags,
6986        }
6987    }
6988}
6989
6990impl From<DhcpConfigurationView> for DhcpConfiguration {
6991    fn from(c: DhcpConfigurationView) -> Self {
6992        DhcpConfiguration {
6993            key: c.key,
6994            values: c.values,
6995        }
6996    }
6997}
6998
6999impl From<EgressOnlyIgwView> for EgressOnlyInternetGateway {
7000    fn from(e: EgressOnlyIgwView) -> Self {
7001        EgressOnlyInternetGateway {
7002            eigw_id: e.eigw_id,
7003            state: e.state,
7004            attachments: e
7005                .attachments
7006                .into_iter()
7007                .map(EoigwAttachment::from)
7008                .collect(),
7009            tags: e.tags,
7010        }
7011    }
7012}
7013
7014impl From<EoigwAttachmentView> for EoigwAttachment {
7015    fn from(a: EoigwAttachmentView) -> Self {
7016        EoigwAttachment {
7017            vpc_id: a.vpc_id,
7018            state: a.state,
7019        }
7020    }
7021}
7022
7023impl From<FlowLogView> for FlowLog {
7024    fn from(f: FlowLogView) -> Self {
7025        FlowLog {
7026            flow_log_id: f.flow_log_id,
7027            resource_id: f.resource_id,
7028            traffic_type: f.traffic_type,
7029            log_destination_type: f.log_destination_type,
7030            log_destination: f.log_destination,
7031            log_group_name: f.log_group_name,
7032            deliver_logs_status: f.deliver_logs_status,
7033            flow_log_status: f.flow_log_status,
7034            tags: f.tags,
7035        }
7036    }
7037}
7038
7039impl From<VpcPeeringConnectionView> for VpcPeeringConnection {
7040    fn from(p: VpcPeeringConnectionView) -> Self {
7041        use crate::types::VpcPeeringConnectionOptions;
7042        VpcPeeringConnection {
7043            peering_id: p.peering_id,
7044            requester_vpc_id: p.requester_vpc_id,
7045            accepter_vpc_id: p.accepter_vpc_id,
7046            status: p.status,
7047            tags: p.tags,
7048            requester_peering_options: p.requester_peering_options.map(|o| {
7049                VpcPeeringConnectionOptions {
7050                    allow_dns_resolution_from_remote_vpc: o.allow_dns_resolution_from_remote_vpc,
7051                    allow_egress_from_local_classic_link_to_remote_vpc: o
7052                        .allow_egress_from_local_classic_link_to_remote_vpc,
7053                    allow_egress_from_local_vpc_to_remote_classic_link: o
7054                        .allow_egress_from_local_vpc_to_remote_classic_link,
7055                }
7056            }),
7057            accepter_peering_options: p.accepter_peering_options.map(|o| {
7058                VpcPeeringConnectionOptions {
7059                    allow_dns_resolution_from_remote_vpc: o.allow_dns_resolution_from_remote_vpc,
7060                    allow_egress_from_local_classic_link_to_remote_vpc: o
7061                        .allow_egress_from_local_classic_link_to_remote_vpc,
7062                    allow_egress_from_local_vpc_to_remote_classic_link: o
7063                        .allow_egress_from_local_vpc_to_remote_classic_link,
7064                }
7065            }),
7066        }
7067    }
7068}
7069
7070impl From<VpcEndpointView> for VpcEndpoint {
7071    fn from(e: VpcEndpointView) -> Self {
7072        VpcEndpoint {
7073            endpoint_id: e.endpoint_id,
7074            vpc_id: e.vpc_id,
7075            service_name: e.service_name,
7076            endpoint_type: e.endpoint_type,
7077            state: e.state,
7078            policy_document: e.policy_document,
7079            route_table_ids: e.route_table_ids,
7080            subnet_ids: e.subnet_ids,
7081            security_group_ids: e.security_group_ids,
7082            private_dns_enabled: e.private_dns_enabled,
7083            tags: e.tags,
7084        }
7085    }
7086}
7087
7088impl From<ManagedPrefixListView> for ManagedPrefixList {
7089    fn from(m: ManagedPrefixListView) -> Self {
7090        ManagedPrefixList {
7091            prefix_list_id: m.prefix_list_id,
7092            prefix_list_name: m.prefix_list_name,
7093            state: m.state,
7094            address_family: m.address_family,
7095            max_entries: m.max_entries,
7096            entries: m
7097                .entries
7098                .into_iter()
7099                .map(TypesPrefixListEntry::from)
7100                .collect(),
7101            tags: m.tags,
7102            version: m.version,
7103            version_history: m
7104                .version_history
7105                .into_iter()
7106                .map(|v| crate::types::ManagedPrefixListVersion {
7107                    version: v.version,
7108                    entries: v
7109                        .entries
7110                        .into_iter()
7111                        .map(TypesPrefixListEntry::from)
7112                        .collect(),
7113                })
7114                .collect(),
7115        }
7116    }
7117}
7118
7119impl From<PrefixListEntryView> for TypesPrefixListEntry {
7120    fn from(e: PrefixListEntryView) -> Self {
7121        TypesPrefixListEntry {
7122            cidr: e.cidr,
7123            description: e.description,
7124        }
7125    }
7126}
7127
7128impl From<CustomerGatewayView> for CustomerGateway {
7129    fn from(c: CustomerGatewayView) -> Self {
7130        CustomerGateway {
7131            customer_gateway_id: c.customer_gateway_id,
7132            bgp_asn: c.bgp_asn,
7133            ip_address: c.ip_address,
7134            gateway_type: c.gateway_type,
7135            state: c.state,
7136            tags: c.tags,
7137        }
7138    }
7139}
7140
7141impl From<VpnGatewayView> for VpnGateway {
7142    fn from(v: VpnGatewayView) -> Self {
7143        VpnGateway {
7144            vpn_gateway_id: v.vpn_gateway_id,
7145            gateway_type: v.gateway_type,
7146            state: v.state,
7147            amazon_side_asn: v.amazon_side_asn,
7148            vpc_attachments: v
7149                .vpc_attachments
7150                .into_iter()
7151                .map(VgwVpcAttachment::from)
7152                .collect(),
7153            tags: v.tags,
7154        }
7155    }
7156}
7157
7158impl From<VgwVpcAttachmentView> for VgwVpcAttachment {
7159    fn from(a: VgwVpcAttachmentView) -> Self {
7160        VgwVpcAttachment {
7161            vpc_id: a.vpc_id,
7162            state: a.state,
7163        }
7164    }
7165}
7166
7167impl From<VpnConnectionView> for VpnConnection {
7168    fn from(c: VpnConnectionView) -> Self {
7169        VpnConnection {
7170            vpn_connection_id: c.vpn_connection_id,
7171            vpn_gateway_id: c.vpn_gateway_id,
7172            customer_gateway_id: c.customer_gateway_id,
7173            transit_gateway_id: c.transit_gateway_id,
7174            connection_type: c.connection_type,
7175            state: c.state,
7176            tags: c.tags,
7177            routes: c.routes.into_iter().map(VpnStaticRoute::from).collect(),
7178            options: c.options.map(VpnConnectionOptions::from),
7179            tunnel_replacement_status: c.tunnel_replacement_status,
7180        }
7181    }
7182}
7183
7184impl From<VpnStaticRouteView> for VpnStaticRoute {
7185    fn from(r: VpnStaticRouteView) -> Self {
7186        VpnStaticRoute {
7187            destination_cidr_block: r.destination_cidr_block,
7188            source: r.source,
7189            state: r.state,
7190        }
7191    }
7192}
7193
7194impl From<VpnConnectionOptionsView> for VpnConnectionOptions {
7195    fn from(o: VpnConnectionOptionsView) -> Self {
7196        VpnConnectionOptions {
7197            local_ipv4_network_cidr: o.local_ipv4_network_cidr,
7198            local_ipv6_network_cidr: o.local_ipv6_network_cidr,
7199            remote_ipv4_network_cidr: o.remote_ipv4_network_cidr,
7200            remote_ipv6_network_cidr: o.remote_ipv6_network_cidr,
7201            tunnel_inside_ip_version: o.tunnel_inside_ip_version,
7202            static_routes_only: o.static_routes_only,
7203            tunnel_options: o
7204                .tunnel_options
7205                .into_iter()
7206                .map(VpnTunnelOptions::from)
7207                .collect(),
7208        }
7209    }
7210}
7211
7212impl From<VpnTunnelOptionsView> for VpnTunnelOptions {
7213    fn from(t: VpnTunnelOptionsView) -> Self {
7214        VpnTunnelOptions {
7215            tunnel_inside_cidr: t.tunnel_inside_cidr,
7216            tunnel_inside_ipv6_cidr: t.tunnel_inside_ipv6_cidr,
7217            pre_shared_key: t.pre_shared_key,
7218            outside_ip_address: t.outside_ip_address,
7219            certificate_arn: t.certificate_arn,
7220        }
7221    }
7222}
7223
7224impl From<VpnConcentratorView> for VpnConcentrator {
7225    fn from(v: VpnConcentratorView) -> Self {
7226        VpnConcentrator {
7227            vpn_concentrator_id: v.vpn_concentrator_id,
7228            concentrator_type: v.concentrator_type,
7229            state: v.state,
7230            transit_gateway_id: v.transit_gateway_id,
7231            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7232            tags: v.tags,
7233        }
7234    }
7235}
7236
7237impl From<VpcEndpointConnectionView> for VpcEndpointConnection {
7238    fn from(c: VpcEndpointConnectionView) -> Self {
7239        VpcEndpointConnection {
7240            service_id: c.service_id,
7241            vpc_endpoint_id: c.vpc_endpoint_id,
7242            vpc_endpoint_owner: c.vpc_endpoint_owner,
7243            vpc_endpoint_state: c.vpc_endpoint_state,
7244            creation_timestamp: c.creation_timestamp,
7245        }
7246    }
7247}
7248
7249impl From<VpcEndpointConnectionNotificationView> for VpcEndpointConnectionNotification {
7250    fn from(n: VpcEndpointConnectionNotificationView) -> Self {
7251        VpcEndpointConnectionNotification {
7252            connection_notification_id: n.connection_notification_id,
7253            connection_notification_arn: n.connection_notification_arn,
7254            connection_events: n.connection_events,
7255            connection_notification_state: n.connection_notification_state,
7256            connection_notification_type: n.connection_notification_type,
7257            service_id: n.service_id,
7258            vpc_endpoint_id: n.vpc_endpoint_id,
7259        }
7260    }
7261}
7262
7263impl From<VpcBlockPublicAccessExclusionView> for VpcBlockPublicAccessExclusion {
7264    fn from(e: VpcBlockPublicAccessExclusionView) -> Self {
7265        VpcBlockPublicAccessExclusion {
7266            exclusion_id: e.exclusion_id,
7267            internet_gateway_exclusion_mode: e.internet_gateway_exclusion_mode,
7268            resource_arn: e.resource_arn,
7269            state: e.state,
7270            creation_timestamp: e.creation_timestamp,
7271            last_update_timestamp: e.last_update_timestamp,
7272            tags: e.tags,
7273        }
7274    }
7275}
7276
7277impl From<VpcBlockPublicAccessOptionsView> for VpcBlockPublicAccessOptions {
7278    fn from(o: VpcBlockPublicAccessOptionsView) -> Self {
7279        VpcBlockPublicAccessOptions {
7280            aws_account_id: o.aws_account_id,
7281            aws_region: o.aws_region,
7282            internet_gateway_block_mode: o.internet_gateway_block_mode,
7283            state: o.state,
7284            last_update_timestamp: o.last_update_timestamp,
7285        }
7286    }
7287}
7288
7289impl From<VpcEncryptionControlView> for VpcEncryptionControl {
7290    fn from(v: VpcEncryptionControlView) -> Self {
7291        VpcEncryptionControl {
7292            vpc_encryption_control_id: v.vpc_encryption_control_id,
7293            vpc_id: v.vpc_id,
7294            mode: v.mode,
7295            state: v.state,
7296            mode_history: v.mode_history,
7297            tags: v.tags,
7298        }
7299    }
7300}
7301
7302impl From<CarrierGatewayView> for CarrierGateway {
7303    fn from(c: CarrierGatewayView) -> Self {
7304        CarrierGateway {
7305            carrier_gateway_id: c.carrier_gateway_id,
7306            vpc_id: c.vpc_id,
7307            state: c.state,
7308            tags: c.tags,
7309        }
7310    }
7311}
7312
7313impl From<NetworkInterfaceView> for NetworkInterface {
7314    fn from(n: NetworkInterfaceView) -> Self {
7315        NetworkInterface {
7316            network_interface_id: n.network_interface_id,
7317            subnet_id: n.subnet_id,
7318            vpc_id: n.vpc_id,
7319            description: n.description,
7320            private_ip_address: n.private_ip_address,
7321            status: n.status,
7322            attachment_id: n.attachment_id,
7323            instance_id: n.instance_id,
7324            device_index: n.device_index,
7325            security_groups: n.security_groups,
7326            source_dest_check: n.source_dest_check,
7327            tags: n.tags,
7328            public_ip_dns_hostname_type: n.public_ip_dns_hostname_type,
7329        }
7330    }
7331}
7332
7333impl From<TransitGatewayView> for TransitGateway {
7334    fn from(t: TransitGatewayView) -> Self {
7335        TransitGateway {
7336            transit_gateway_id: t.transit_gateway_id,
7337            state: t.state,
7338            amazon_side_asn: t.amazon_side_asn,
7339            description: t.description,
7340            dns_support: t.dns_support,
7341            vpn_ecmp_support: t.vpn_ecmp_support,
7342            multicast_support: t.multicast_support,
7343            tags: t.tags,
7344        }
7345    }
7346}
7347
7348impl From<TgwVpcAttachmentView> for TransitGatewayVpcAttachment {
7349    fn from(a: TgwVpcAttachmentView) -> Self {
7350        TransitGatewayVpcAttachment {
7351            attachment_id: a.attachment_id,
7352            transit_gateway_id: a.transit_gateway_id,
7353            vpc_id: a.vpc_id,
7354            subnet_ids: a.subnet_ids,
7355            state: a.state,
7356            tags: a.tags,
7357        }
7358    }
7359}
7360
7361impl From<TgwPeeringAttachmentView> for TransitGatewayPeeringAttachment {
7362    fn from(a: TgwPeeringAttachmentView) -> Self {
7363        TransitGatewayPeeringAttachment {
7364            attachment_id: a.attachment_id,
7365            transit_gateway_id: a.transit_gateway_id,
7366            peer_transit_gateway_id: a.peer_transit_gateway_id,
7367            peer_account_id: a.peer_account_id,
7368            peer_region: a.peer_region,
7369            state: a.state,
7370            tags: a.tags,
7371        }
7372    }
7373}
7374
7375impl From<TgwRouteTableView> for TransitGatewayRouteTable {
7376    fn from(t: TgwRouteTableView) -> Self {
7377        TransitGatewayRouteTable {
7378            route_table_id: t.route_table_id,
7379            transit_gateway_id: t.transit_gateway_id,
7380            state: t.state,
7381            default_association_route_table: t.default_association_route_table,
7382            default_propagation_route_table: t.default_propagation_route_table,
7383            tags: t.tags,
7384        }
7385    }
7386}
7387
7388impl From<TgwRouteView> for TransitGatewayRoute {
7389    fn from(r: TgwRouteView) -> Self {
7390        TransitGatewayRoute {
7391            destination_cidr_block: r.destination_cidr_block,
7392            route_type: r.route_type,
7393            state: r.state,
7394            attachment_id: r.attachment_id,
7395        }
7396    }
7397}
7398
7399// --- Group 11: View → internal `From` impls ---
7400
7401impl From<TransitGatewayMulticastDomainView> for TransitGatewayMulticastDomain {
7402    fn from(v: TransitGatewayMulticastDomainView) -> Self {
7403        TransitGatewayMulticastDomain {
7404            transit_gateway_multicast_domain_id: v.transit_gateway_multicast_domain_id,
7405            transit_gateway_id: v.transit_gateway_id,
7406            transit_gateway_multicast_domain_arn: v.transit_gateway_multicast_domain_arn,
7407            owner_id: v.owner_id,
7408            igmpv2_support: v.igmpv2_support,
7409            static_sources_support: v.static_sources_support,
7410            auto_accept_shared_associations: v.auto_accept_shared_associations,
7411            state: v.state,
7412            creation_time: v.creation_time,
7413            tags: v.tags,
7414        }
7415    }
7416}
7417
7418impl From<MulticastSubnetAssociationView> for MulticastSubnetAssociation {
7419    fn from(v: MulticastSubnetAssociationView) -> Self {
7420        MulticastSubnetAssociation {
7421            subnet_id: v.subnet_id,
7422            state: v.state,
7423        }
7424    }
7425}
7426
7427impl From<TransitGatewayMulticastDomainAssociationView>
7428    for TransitGatewayMulticastDomainAssociation
7429{
7430    fn from(v: TransitGatewayMulticastDomainAssociationView) -> Self {
7431        TransitGatewayMulticastDomainAssociation {
7432            transit_gateway_multicast_domain_id: v.transit_gateway_multicast_domain_id,
7433            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7434            resource_id: v.resource_id,
7435            resource_type: v.resource_type,
7436            subnets: v
7437                .subnets
7438                .into_iter()
7439                .map(MulticastSubnetAssociation::from)
7440                .collect(),
7441        }
7442    }
7443}
7444
7445impl From<TransitGatewayMulticastGroupMemberView> for TransitGatewayMulticastGroupMember {
7446    fn from(v: TransitGatewayMulticastGroupMemberView) -> Self {
7447        TransitGatewayMulticastGroupMember {
7448            transit_gateway_multicast_domain_id: v.transit_gateway_multicast_domain_id,
7449            group_ip_address: v.group_ip_address,
7450            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7451            subnet_id: v.subnet_id,
7452            resource_id: v.resource_id,
7453            resource_type: v.resource_type,
7454            network_interface_id: v.network_interface_id,
7455            member_type: v.member_type,
7456            source_type: v.source_type,
7457        }
7458    }
7459}
7460
7461impl From<TransitGatewayMulticastGroupSourceView> for TransitGatewayMulticastGroupSource {
7462    fn from(v: TransitGatewayMulticastGroupSourceView) -> Self {
7463        TransitGatewayMulticastGroupSource {
7464            transit_gateway_multicast_domain_id: v.transit_gateway_multicast_domain_id,
7465            group_ip_address: v.group_ip_address,
7466            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7467            subnet_id: v.subnet_id,
7468            resource_id: v.resource_id,
7469            resource_type: v.resource_type,
7470            network_interface_id: v.network_interface_id,
7471            member_type: v.member_type,
7472            source_type: v.source_type,
7473        }
7474    }
7475}
7476
7477impl From<TransitGatewayConnectView> for TransitGatewayConnect {
7478    fn from(v: TransitGatewayConnectView) -> Self {
7479        TransitGatewayConnect {
7480            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7481            transport_transit_gateway_attachment_id: v.transport_transit_gateway_attachment_id,
7482            transit_gateway_id: v.transit_gateway_id,
7483            state: v.state,
7484            creation_time: v.creation_time,
7485            protocol: v.protocol,
7486            tags: v.tags,
7487        }
7488    }
7489}
7490
7491impl From<TransitGatewayAttachmentBgpConfigurationView>
7492    for TransitGatewayAttachmentBgpConfiguration
7493{
7494    fn from(v: TransitGatewayAttachmentBgpConfigurationView) -> Self {
7495        TransitGatewayAttachmentBgpConfiguration {
7496            transit_gateway_asn: v.transit_gateway_asn,
7497            peer_asn: v.peer_asn,
7498            transit_gateway_address: v.transit_gateway_address,
7499            peer_address: v.peer_address,
7500            bgp_status: v.bgp_status,
7501        }
7502    }
7503}
7504
7505impl From<TransitGatewayConnectPeerView> for TransitGatewayConnectPeer {
7506    fn from(v: TransitGatewayConnectPeerView) -> Self {
7507        TransitGatewayConnectPeer {
7508            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7509            transit_gateway_connect_peer_id: v.transit_gateway_connect_peer_id,
7510            state: v.state,
7511            creation_time: v.creation_time,
7512            transit_gateway_address: v.transit_gateway_address,
7513            peer_address: v.peer_address,
7514            inside_cidr_blocks: v.inside_cidr_blocks,
7515            protocol: v.protocol,
7516            bgp_configurations: v
7517                .bgp_configurations
7518                .into_iter()
7519                .map(TransitGatewayAttachmentBgpConfiguration::from)
7520                .collect(),
7521            tags: v.tags,
7522        }
7523    }
7524}
7525
7526impl From<TransitGatewayMeteringPolicyView> for TransitGatewayMeteringPolicy {
7527    fn from(v: TransitGatewayMeteringPolicyView) -> Self {
7528        TransitGatewayMeteringPolicy {
7529            transit_gateway_metering_policy_id: v.transit_gateway_metering_policy_id,
7530            transit_gateway_metering_policy_arn: v.transit_gateway_metering_policy_arn,
7531            transit_gateway_id: v.transit_gateway_id,
7532            name: v.name,
7533            description: v.description,
7534            state: v.state,
7535            tags: v.tags,
7536            last_updated_time: v.last_updated_time,
7537            version: v.version,
7538            middlebox_attachment_ids: v.middlebox_attachment_ids,
7539        }
7540    }
7541}
7542
7543impl From<TransitGatewayMeteringPolicyEntryView> for TransitGatewayMeteringPolicyEntry {
7544    fn from(v: TransitGatewayMeteringPolicyEntryView) -> Self {
7545        TransitGatewayMeteringPolicyEntry {
7546            transit_gateway_metering_policy_entry_id: v.transit_gateway_metering_policy_entry_id,
7547            transit_gateway_metering_policy_id: v.transit_gateway_metering_policy_id,
7548            sequence_number: v.sequence_number,
7549            action: v.action,
7550            source_cidr_block: v.source_cidr_block,
7551            destination_cidr_block: v.destination_cidr_block,
7552            protocol: v.protocol,
7553            source_port: v.source_port,
7554            destination_port: v.destination_port,
7555            dimensions: v.dimensions,
7556            state: v.state,
7557        }
7558    }
7559}
7560
7561impl From<TransitGatewayPolicyTableView> for TransitGatewayPolicyTable {
7562    fn from(v: TransitGatewayPolicyTableView) -> Self {
7563        TransitGatewayPolicyTable {
7564            transit_gateway_policy_table_id: v.transit_gateway_policy_table_id,
7565            transit_gateway_id: v.transit_gateway_id,
7566            state: v.state,
7567            creation_time: v.creation_time,
7568            tags: v.tags,
7569        }
7570    }
7571}
7572
7573impl From<TransitGatewayPolicyTableAssociationView> for TransitGatewayPolicyTableAssociation {
7574    fn from(v: TransitGatewayPolicyTableAssociationView) -> Self {
7575        TransitGatewayPolicyTableAssociation {
7576            transit_gateway_policy_table_id: v.transit_gateway_policy_table_id,
7577            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7578            resource_type: v.resource_type,
7579            resource_id: v.resource_id,
7580            state: v.state,
7581        }
7582    }
7583}
7584
7585impl From<TransitGatewayPrefixListReferenceView> for TransitGatewayPrefixListReference {
7586    fn from(v: TransitGatewayPrefixListReferenceView) -> Self {
7587        TransitGatewayPrefixListReference {
7588            transit_gateway_route_table_id: v.transit_gateway_route_table_id,
7589            prefix_list_id: v.prefix_list_id,
7590            prefix_list_owner_id: v.prefix_list_owner_id,
7591            state: v.state,
7592            blackhole: v.blackhole,
7593            transit_gateway_attachment_id: v.transit_gateway_attachment_id,
7594            resource_id: v.resource_id,
7595            resource_type: v.resource_type,
7596        }
7597    }
7598}
7599
7600impl From<TransitGatewayRouteTableAnnouncementView> for TransitGatewayRouteTableAnnouncement {
7601    fn from(v: TransitGatewayRouteTableAnnouncementView) -> Self {
7602        TransitGatewayRouteTableAnnouncement {
7603            transit_gateway_route_table_announcement_id: v
7604                .transit_gateway_route_table_announcement_id,
7605            transit_gateway_id: v.transit_gateway_id,
7606            core_network_id: v.core_network_id,
7607            peer_transit_gateway_id: v.peer_transit_gateway_id,
7608            peer_core_network_id: v.peer_core_network_id,
7609            peering_attachment_id: v.peering_attachment_id,
7610            announcement_direction: v.announcement_direction,
7611            transit_gateway_route_table_id: v.transit_gateway_route_table_id,
7612            state: v.state,
7613            creation_time: v.creation_time,
7614            tags: v.tags,
7615        }
7616    }
7617}
7618
7619impl From<InstanceView> for Instance {
7620    fn from(i: InstanceView) -> Self {
7621        Instance {
7622            instance_id: i.instance_id,
7623            image_id: i.image_id,
7624            instance_type: i.instance_type,
7625            state: InstanceState {
7626                code: i.state.code,
7627                name: i.state.name,
7628            },
7629            private_ip_address: i.private_ip_address,
7630            public_ip_address: i.public_ip_address,
7631            subnet_id: i.subnet_id,
7632            vpc_id: i.vpc_id,
7633            key_name: i.key_name,
7634            security_groups: i.security_groups,
7635            launch_time: i.launch_time,
7636            tags: i.tags,
7637            iam_instance_profile_arn: i.iam_instance_profile_arn,
7638            monitoring_state: i.monitoring_state,
7639            placement_az: i.placement_az,
7640            placement_group_name: i.placement_group_name,
7641            placement_tenancy: i.placement_tenancy,
7642            placement_host_id: i.placement_host_id,
7643            placement_affinity: i.placement_affinity,
7644            placement_partition_number: i.placement_partition_number,
7645            owner_id: i.owner_id,
7646            classic_link_vpc: i.classic_link_vpc,
7647            private_dns_hostname_type: i.private_dns_hostname_type,
7648            enable_resource_name_dns_a_record: i.enable_resource_name_dns_a_record,
7649            enable_resource_name_dns_aaaa_record: i.enable_resource_name_dns_aaaa_record,
7650            credit_specification: i.credit_specification,
7651            cpu_options: i.cpu_options.map(|c| crate::types::InstanceCpuOptions {
7652                core_count: c.core_count,
7653                threads_per_core: c.threads_per_core,
7654                amd_sev_snp: c.amd_sev_snp,
7655            }),
7656            maintenance_options: i.maintenance_options.map(|m| {
7657                crate::types::InstanceMaintenanceOptions {
7658                    auto_recovery: m.auto_recovery,
7659                    reboot_migration: m.reboot_migration,
7660                }
7661            }),
7662            network_bandwidth_weighting: i.network_bandwidth_weighting,
7663            lifecycle: i.lifecycle,
7664            product_codes: i.product_codes,
7665            capacity_reservation_specification: i
7666                .capacity_reservation_specification
7667                .map(CapacityReservationSpecificationResponse::from),
7668        }
7669    }
7670}
7671
7672impl From<CapacityReservationFleetView> for CapacityReservationFleet {
7673    fn from(v: CapacityReservationFleetView) -> Self {
7674        CapacityReservationFleet {
7675            capacity_reservation_fleet_id: v.capacity_reservation_fleet_id,
7676            capacity_reservation_fleet_arn: v.capacity_reservation_fleet_arn,
7677            state: v.state,
7678            tenancy: v.tenancy,
7679            allocation_strategy: v.allocation_strategy,
7680            instance_match_criteria: v.instance_match_criteria,
7681            total_target_capacity: v.total_target_capacity,
7682            total_fulfilled_capacity: v.total_fulfilled_capacity,
7683            create_time: v.create_time,
7684            end_date: v.end_date,
7685            instance_type_specifications: v
7686                .instance_type_specifications
7687                .into_iter()
7688                .map(CapacityReservationFleetInstanceSpec::from)
7689                .collect(),
7690            tags: v.tags,
7691        }
7692    }
7693}
7694
7695impl From<CapacityReservationFleetInstanceSpecView> for CapacityReservationFleetInstanceSpec {
7696    fn from(v: CapacityReservationFleetInstanceSpecView) -> Self {
7697        CapacityReservationFleetInstanceSpec {
7698            instance_type: v.instance_type,
7699            instance_platform: v.instance_platform,
7700            availability_zone: v.availability_zone,
7701            ebs_optimized: v.ebs_optimized,
7702            priority: v.priority,
7703            weight: v.weight,
7704        }
7705    }
7706}
7707
7708impl From<VolumeAttachmentView> for VolumeAttachment {
7709    fn from(a: VolumeAttachmentView) -> Self {
7710        VolumeAttachment {
7711            volume_id: a.volume_id,
7712            instance_id: a.instance_id,
7713            device: a.device,
7714            state: a.state,
7715            attach_time: a.attach_time,
7716            delete_on_termination: a.delete_on_termination,
7717        }
7718    }
7719}
7720
7721impl From<VolumeView> for Volume {
7722    fn from(v: VolumeView) -> Self {
7723        Volume {
7724            volume_id: v.volume_id,
7725            size: v.size,
7726            snapshot_id: v.snapshot_id,
7727            availability_zone: v.availability_zone,
7728            state: v.state,
7729            volume_type: v.volume_type,
7730            iops: v.iops,
7731            throughput: v.throughput,
7732            encrypted: v.encrypted,
7733            create_time: v.create_time,
7734            attachments: v
7735                .attachments
7736                .into_iter()
7737                .map(VolumeAttachment::from)
7738                .collect(),
7739            tags: v.tags,
7740            recycle_bin_state: v.recycle_bin_state,
7741            source_volume_id: v.source_volume_id,
7742        }
7743    }
7744}
7745
7746impl From<SnapshotView> for Snapshot {
7747    fn from(s: SnapshotView) -> Self {
7748        use crate::types::FastSnapshotRestoreState;
7749        Snapshot {
7750            snapshot_id: s.snapshot_id,
7751            volume_id: s.volume_id,
7752            volume_size: s.volume_size,
7753            state: s.state,
7754            description: s.description,
7755            start_time: s.start_time,
7756            progress: s.progress,
7757            owner_id: s.owner_id,
7758            encrypted: s.encrypted,
7759            tags: s.tags,
7760            lock_state: s.lock_state,
7761            lock_duration: s.lock_duration,
7762            lock_created_on: s.lock_created_on,
7763            lock_expires_on: s.lock_expires_on,
7764            lock_duration_start_time: s.lock_duration_start_time,
7765            cool_off_period: s.cool_off_period,
7766            cool_off_period_expires_on: s.cool_off_period_expires_on,
7767            storage_tier: s.storage_tier,
7768            last_tiering_operation_status: s.last_tiering_operation_status,
7769            fast_snapshot_restore_states: s
7770                .fast_snapshot_restore_states
7771                .into_iter()
7772                .map(|f| FastSnapshotRestoreState {
7773                    availability_zone: f.availability_zone,
7774                    state: f.state,
7775                })
7776                .collect(),
7777        }
7778    }
7779}
7780
7781impl From<ImageView> for Image {
7782    fn from(i: ImageView) -> Self {
7783        Image {
7784            image_id: i.image_id,
7785            name: i.name,
7786            description: i.description,
7787            state: i.state,
7788            owner_id: i.owner_id,
7789            architecture: i.architecture,
7790            image_type: i.image_type,
7791            platform: i.platform,
7792            virtualization_type: i.virtualization_type,
7793            root_device_type: i.root_device_type,
7794            root_device_name: i.root_device_name,
7795            public: i.public,
7796            tags: i.tags,
7797            source_instance_id: i.source_instance_id,
7798            source_instance_type: i.source_instance_type,
7799            launch_permissions: i
7800                .launch_permissions
7801                .into_iter()
7802                .map(crate::types::LaunchPermission::from)
7803                .collect(),
7804            recycle_bin_state: i.recycle_bin_state,
7805            deprecation_time: i.deprecation_time,
7806            recycle_bin_enter_time: i.recycle_bin_enter_time,
7807            product_codes: i.product_codes,
7808            fast_launch_state: i.fast_launch_state.map(crate::types::FastLaunchState::from),
7809            deregistration_protection: i.deregistration_protection,
7810            kernel_id: i.kernel_id,
7811            ramdisk_id: i.ramdisk_id,
7812            ena_support: i.ena_support,
7813            sriov_net_support: i.sriov_net_support,
7814            tpm_support: i.tpm_support,
7815            boot_mode: i.boot_mode,
7816            imds_support: i.imds_support,
7817            image_location: i.image_location,
7818            source_image_id: i.source_image_id,
7819            source_region: i.source_region,
7820        }
7821    }
7822}
7823
7824impl From<LaunchPermissionView> for crate::types::LaunchPermission {
7825    fn from(p: LaunchPermissionView) -> Self {
7826        crate::types::LaunchPermission {
7827            user_id: p.user_id,
7828            group: p.group,
7829        }
7830    }
7831}
7832
7833impl From<LaunchTemplateView> for LaunchTemplate {
7834    fn from(t: LaunchTemplateView) -> Self {
7835        LaunchTemplate {
7836            launch_template_id: t.launch_template_id,
7837            launch_template_name: t.launch_template_name,
7838            default_version_number: t.default_version_number,
7839            latest_version_number: t.latest_version_number,
7840            tags: t.tags,
7841        }
7842    }
7843}
7844
7845impl From<LaunchTemplateVersionView> for LaunchTemplateVersion {
7846    fn from(v: LaunchTemplateVersionView) -> Self {
7847        LaunchTemplateVersion {
7848            version_number: v.version_number,
7849            launch_template_id: v.launch_template_id,
7850            launch_template_name: v.launch_template_name,
7851            version_description: v.version_description,
7852            data: v.data,
7853            default_version: v.default_version,
7854        }
7855    }
7856}
7857
7858impl From<SpotInstanceRequestView> for SpotInstanceRequest {
7859    fn from(s: SpotInstanceRequestView) -> Self {
7860        SpotInstanceRequest {
7861            spot_instance_request_id: s.spot_instance_request_id,
7862            spot_price: s.spot_price,
7863            instance_type: s.instance_type,
7864            image_id: s.image_id,
7865            state: s.state,
7866            status_code: s.status_code,
7867            instance_id: s.instance_id,
7868            tags: s.tags,
7869        }
7870    }
7871}
7872
7873impl From<SpotDatafeedSubscriptionView> for crate::types::SpotDatafeedSubscription {
7874    fn from(v: SpotDatafeedSubscriptionView) -> Self {
7875        crate::types::SpotDatafeedSubscription {
7876            bucket: v.bucket,
7877            prefix: v.prefix,
7878            owner_id: v.owner_id,
7879            state: v.state,
7880        }
7881    }
7882}
7883
7884impl From<IamInstanceProfileAssociationView> for IamInstanceProfileAssociation {
7885    fn from(a: IamInstanceProfileAssociationView) -> Self {
7886        IamInstanceProfileAssociation {
7887            association_id: a.association_id,
7888            instance_id: a.instance_id,
7889            iam_instance_profile_arn: a.iam_instance_profile_arn,
7890            iam_instance_profile_name: a.iam_instance_profile_name,
7891            state: a.state,
7892        }
7893    }
7894}
7895
7896impl From<DedicatedHostView> for DedicatedHost {
7897    fn from(h: DedicatedHostView) -> Self {
7898        DedicatedHost {
7899            host_id: h.host_id,
7900            availability_zone: h.availability_zone,
7901            instance_type: h.instance_type,
7902            auto_placement: h.auto_placement,
7903            host_recovery: h.host_recovery,
7904            state: h.state,
7905            tags: h.tags,
7906        }
7907    }
7908}
7909
7910impl From<Ec2FleetView> for Ec2Fleet {
7911    fn from(f: Ec2FleetView) -> Self {
7912        Ec2Fleet {
7913            fleet_id: f.fleet_id,
7914            state: f.state,
7915            fleet_type: f.fleet_type,
7916            create_time: f.create_time,
7917            tags: f.tags,
7918            total_target_capacity: f.total_target_capacity,
7919            on_demand_target_capacity: f.on_demand_target_capacity,
7920            spot_target_capacity: f.spot_target_capacity,
7921            context: f.context,
7922        }
7923    }
7924}
7925
7926impl From<VpcEndpointServiceConfigView> for VpcEndpointServiceConfiguration {
7927    fn from(s: VpcEndpointServiceConfigView) -> Self {
7928        VpcEndpointServiceConfiguration {
7929            service_id: s.service_id,
7930            service_name: s.service_name,
7931            service_type: s.service_type,
7932            acceptance_required: s.acceptance_required,
7933            state: s.state,
7934            network_load_balancer_arns: s.network_load_balancer_arns,
7935            gateway_load_balancer_arns: s.gateway_load_balancer_arns,
7936            allowed_principals: s.allowed_principals,
7937            tags: s.tags,
7938            payer_responsibility: s.payer_responsibility,
7939            private_dns_state: s.private_dns_state,
7940        }
7941    }
7942}
7943
7944impl From<SpotFleetRequestView> for SpotFleetRequest {
7945    fn from(s: SpotFleetRequestView) -> Self {
7946        SpotFleetRequest {
7947            spot_fleet_request_id: s.spot_fleet_request_id,
7948            spot_fleet_request_state: s.spot_fleet_request_state,
7949            target_capacity: s.target_capacity,
7950            iam_fleet_role: s.iam_fleet_role,
7951            create_time: s.create_time,
7952            tags: s.tags,
7953        }
7954    }
7955}
7956
7957impl From<SubnetCidrReservationView> for SubnetCidrReservationEntry {
7958    fn from(r: SubnetCidrReservationView) -> Self {
7959        SubnetCidrReservationEntry {
7960            reservation_id: r.reservation_id,
7961            subnet_id: r.subnet_id,
7962            cidr: r.cidr,
7963            reservation_type: r.reservation_type,
7964            description: r.description,
7965            owner_id: r.owner_id,
7966        }
7967    }
7968}
7969
7970impl From<PlacementGroupView> for PlacementGroup {
7971    fn from(p: PlacementGroupView) -> Self {
7972        PlacementGroup {
7973            group_id: p.group_id,
7974            group_name: p.group_name,
7975            group_arn: p.group_arn,
7976            strategy: p.strategy,
7977            state: p.state,
7978            partition_count: p.partition_count,
7979            spread_level: p.spread_level,
7980            tags: p.tags,
7981        }
7982    }
7983}
7984
7985impl From<NetworkInterfacePermissionView> for NetworkInterfacePermission {
7986    fn from(p: NetworkInterfacePermissionView) -> Self {
7987        NetworkInterfacePermission {
7988            network_interface_permission_id: p.network_interface_permission_id,
7989            network_interface_id: p.network_interface_id,
7990            aws_account_id: p.aws_account_id,
7991            aws_service: p.aws_service,
7992            permission: p.permission,
7993            permission_state: p.permission_state,
7994        }
7995    }
7996}
7997
7998impl From<CapacityReservationView> for CapacityReservation {
7999    fn from(c: CapacityReservationView) -> Self {
8000        CapacityReservation {
8001            capacity_reservation_id: c.capacity_reservation_id,
8002            capacity_reservation_arn: c.capacity_reservation_arn,
8003            owner_id: c.owner_id,
8004            instance_type: c.instance_type,
8005            instance_platform: c.instance_platform,
8006            availability_zone: c.availability_zone,
8007            tenancy: c.tenancy,
8008            total_instance_count: c.total_instance_count,
8009            available_instance_count: c.available_instance_count,
8010            ebs_optimized: c.ebs_optimized,
8011            ephemeral_storage: c.ephemeral_storage,
8012            state: c.state,
8013            start_date: c.start_date,
8014            end_date: c.end_date,
8015            end_date_type: c.end_date_type,
8016            instance_match_criteria: c.instance_match_criteria,
8017            create_date: c.create_date,
8018            outpost_arn: c.outpost_arn,
8019            placement_group_arn: c.placement_group_arn,
8020            tags: c.tags,
8021            pending_billing_owner_account_id: c.pending_billing_owner_account_id,
8022            billing_owner_account_id: c.billing_owner_account_id,
8023            target_capacity_reservation_id: c.target_capacity_reservation_id,
8024            reservation_type: c.reservation_type,
8025            commitment_info: c
8026                .commitment_info
8027                .map(CapacityReservationCommitmentInfo::from),
8028        }
8029    }
8030}
8031
8032impl From<&CoipPool> for CoipPoolView {
8033    fn from(p: &CoipPool) -> Self {
8034        CoipPoolView {
8035            pool_id: p.pool_id.clone(),
8036            pool_arn: p.pool_arn.clone(),
8037            local_gateway_route_table_id: p.local_gateway_route_table_id.clone(),
8038            pool_cidrs: p.pool_cidrs.clone(),
8039            tags: p.tags.clone(),
8040        }
8041    }
8042}
8043
8044impl From<CoipPoolView> for CoipPool {
8045    fn from(v: CoipPoolView) -> Self {
8046        CoipPool {
8047            pool_id: v.pool_id,
8048            pool_arn: v.pool_arn,
8049            local_gateway_route_table_id: v.local_gateway_route_table_id,
8050            pool_cidrs: v.pool_cidrs,
8051            tags: v.tags,
8052        }
8053    }
8054}
8055
8056impl From<&SecurityGroupVpcAssociation> for SecurityGroupVpcAssociationView {
8057    fn from(a: &SecurityGroupVpcAssociation) -> Self {
8058        SecurityGroupVpcAssociationView {
8059            group_id: a.group_id.clone(),
8060            vpc_id: a.vpc_id.clone(),
8061            vpc_owner_id: a.vpc_owner_id.clone(),
8062            state: a.state.clone(),
8063        }
8064    }
8065}
8066
8067impl From<SecurityGroupVpcAssociationView> for SecurityGroupVpcAssociation {
8068    fn from(v: SecurityGroupVpcAssociationView) -> Self {
8069        SecurityGroupVpcAssociation {
8070            group_id: v.group_id,
8071            vpc_id: v.vpc_id,
8072            vpc_owner_id: v.vpc_owner_id,
8073            state: v.state,
8074        }
8075    }
8076}
8077
8078impl From<&EnclaveCertificateIamRoleAssociation> for EnclaveCertificateIamRoleAssociationView {
8079    fn from(a: &EnclaveCertificateIamRoleAssociation) -> Self {
8080        EnclaveCertificateIamRoleAssociationView {
8081            certificate_arn: a.certificate_arn.clone(),
8082            role_arn: a.role_arn.clone(),
8083            certificate_s3_bucket_name: a.certificate_s3_bucket_name.clone(),
8084            certificate_s3_object_key: a.certificate_s3_object_key.clone(),
8085            encryption_kms_key_id: a.encryption_kms_key_id.clone(),
8086        }
8087    }
8088}
8089
8090impl From<EnclaveCertificateIamRoleAssociationView> for EnclaveCertificateIamRoleAssociation {
8091    fn from(v: EnclaveCertificateIamRoleAssociationView) -> Self {
8092        EnclaveCertificateIamRoleAssociation {
8093            certificate_arn: v.certificate_arn,
8094            role_arn: v.role_arn,
8095            certificate_s3_bucket_name: v.certificate_s3_bucket_name,
8096            certificate_s3_object_key: v.certificate_s3_object_key,
8097            encryption_kms_key_id: v.encryption_kms_key_id,
8098        }
8099    }
8100}
8101
8102impl From<&MacSipModificationTask> for MacSipModificationTaskView {
8103    fn from(t: &MacSipModificationTask) -> Self {
8104        MacSipModificationTaskView {
8105            task_id: t.task_id.clone(),
8106            instance_id: t.instance_id.clone(),
8107            task_type: t.task_type.clone(),
8108            task_state: t.task_state.clone(),
8109            start_time: t.start_time.clone(),
8110            apple_internal: t.apple_internal.clone(),
8111            base_system: t.base_system.clone(),
8112            debugging_restrictions: t.debugging_restrictions.clone(),
8113            dtrace_restrictions: t.dtrace_restrictions.clone(),
8114            filesystem_protections: t.filesystem_protections.clone(),
8115            kext_signing: t.kext_signing.clone(),
8116            nvram_protections: t.nvram_protections.clone(),
8117            status: t.status.clone(),
8118            tags: t.tags.clone(),
8119        }
8120    }
8121}
8122
8123impl From<MacSipModificationTaskView> for MacSipModificationTask {
8124    fn from(v: MacSipModificationTaskView) -> Self {
8125        MacSipModificationTask {
8126            task_id: v.task_id,
8127            instance_id: v.instance_id,
8128            task_type: v.task_type,
8129            task_state: v.task_state,
8130            start_time: v.start_time,
8131            apple_internal: v.apple_internal,
8132            base_system: v.base_system,
8133            debugging_restrictions: v.debugging_restrictions,
8134            dtrace_restrictions: v.dtrace_restrictions,
8135            filesystem_protections: v.filesystem_protections,
8136            kext_signing: v.kext_signing,
8137            nvram_protections: v.nvram_protections,
8138            status: v.status,
8139            tags: v.tags,
8140        }
8141    }
8142}
8143
8144impl From<&DeclarativePoliciesReport> for DeclarativePoliciesReportView {
8145    fn from(r: &DeclarativePoliciesReport) -> Self {
8146        DeclarativePoliciesReportView {
8147            report_id: r.report_id.clone(),
8148            s3_bucket: r.s3_bucket.clone(),
8149            s3_prefix: r.s3_prefix.clone(),
8150            target_id: r.target_id.clone(),
8151            status: r.status.clone(),
8152            start_time: r.start_time.clone(),
8153            end_time: r.end_time.clone(),
8154            tags: r.tags.clone(),
8155        }
8156    }
8157}
8158
8159impl From<DeclarativePoliciesReportView> for DeclarativePoliciesReport {
8160    fn from(v: DeclarativePoliciesReportView) -> Self {
8161        DeclarativePoliciesReport {
8162            report_id: v.report_id,
8163            s3_bucket: v.s3_bucket,
8164            s3_prefix: v.s3_prefix,
8165            target_id: v.target_id,
8166            status: v.status,
8167            start_time: v.start_time,
8168            end_time: v.end_time,
8169            tags: v.tags,
8170        }
8171    }
8172}
8173
8174impl From<InstanceConnectEndpointView> for InstanceConnectEndpoint {
8175    fn from(i: InstanceConnectEndpointView) -> Self {
8176        InstanceConnectEndpoint {
8177            instance_connect_endpoint_id: i.instance_connect_endpoint_id,
8178            instance_connect_endpoint_arn: i.instance_connect_endpoint_arn,
8179            subnet_id: i.subnet_id,
8180            vpc_id: i.vpc_id,
8181            availability_zone: i.availability_zone,
8182            state: i.state,
8183            created_at: i.created_at,
8184            preserve_client_ip: i.preserve_client_ip,
8185            security_group_ids: i.security_group_ids,
8186            network_interface_ids: i.network_interface_ids,
8187            dns_name: i.dns_name,
8188            fips_dns_name: i.fips_dns_name,
8189            ip_address_type: i.ip_address_type,
8190            owner_id: i.owner_id,
8191            tags: i.tags,
8192        }
8193    }
8194}
8195
8196// ---------------------------------------------------------------------------
8197// Group 4: View structs + round-trip From impls
8198// ---------------------------------------------------------------------------
8199
8200#[derive(Debug, Clone, Serialize, Deserialize)]
8201pub struct MacVolumeOwnershipTaskView {
8202    pub task_id: String,
8203    pub mac_volume_ownership_task_state: String,
8204    pub volume_id: String,
8205    pub source_volume_owner_account_id: String,
8206    pub target_volume_owner_account_id: String,
8207    pub creation_time: String,
8208    #[serde(default)]
8209    pub completion_time: Option<String>,
8210}
8211
8212impl From<&MacVolumeOwnershipTask> for MacVolumeOwnershipTaskView {
8213    fn from(t: &MacVolumeOwnershipTask) -> Self {
8214        Self {
8215            task_id: t.task_id.clone(),
8216            mac_volume_ownership_task_state: t.mac_volume_ownership_task_state.clone(),
8217            volume_id: t.volume_id.clone(),
8218            source_volume_owner_account_id: t.source_volume_owner_account_id.clone(),
8219            target_volume_owner_account_id: t.target_volume_owner_account_id.clone(),
8220            creation_time: t.creation_time.clone(),
8221            completion_time: t.completion_time.clone(),
8222        }
8223    }
8224}
8225
8226impl From<MacVolumeOwnershipTaskView> for MacVolumeOwnershipTask {
8227    fn from(v: MacVolumeOwnershipTaskView) -> Self {
8228        Self {
8229            task_id: v.task_id,
8230            mac_volume_ownership_task_state: v.mac_volume_ownership_task_state,
8231            volume_id: v.volume_id,
8232            source_volume_owner_account_id: v.source_volume_owner_account_id,
8233            target_volume_owner_account_id: v.target_volume_owner_account_id,
8234            creation_time: v.creation_time,
8235            completion_time: v.completion_time,
8236        }
8237    }
8238}
8239
8240#[derive(Debug, Clone, Serialize, Deserialize)]
8241pub struct ReplaceRootVolumeTaskView {
8242    pub task_id: String,
8243    pub instance_id: String,
8244    pub task_state: String,
8245    #[serde(default)]
8246    pub image_id: Option<String>,
8247    #[serde(default)]
8248    pub snapshot_id: Option<String>,
8249    pub delete_replaced_root_volume: bool,
8250    pub start_time: String,
8251    #[serde(default)]
8252    pub complete_time: Option<String>,
8253    #[serde(default)]
8254    pub tags: HashMap<String, String>,
8255}
8256
8257impl From<&ReplaceRootVolumeTask> for ReplaceRootVolumeTaskView {
8258    fn from(t: &ReplaceRootVolumeTask) -> Self {
8259        Self {
8260            task_id: t.task_id.clone(),
8261            instance_id: t.instance_id.clone(),
8262            task_state: t.task_state.clone(),
8263            image_id: t.image_id.clone(),
8264            snapshot_id: t.snapshot_id.clone(),
8265            delete_replaced_root_volume: t.delete_replaced_root_volume,
8266            start_time: t.start_time.clone(),
8267            complete_time: t.complete_time.clone(),
8268            tags: t.tags.clone(),
8269        }
8270    }
8271}
8272
8273impl From<ReplaceRootVolumeTaskView> for ReplaceRootVolumeTask {
8274    fn from(v: ReplaceRootVolumeTaskView) -> Self {
8275        Self {
8276            task_id: v.task_id,
8277            instance_id: v.instance_id,
8278            task_state: v.task_state,
8279            image_id: v.image_id,
8280            snapshot_id: v.snapshot_id,
8281            delete_replaced_root_volume: v.delete_replaced_root_volume,
8282            start_time: v.start_time,
8283            complete_time: v.complete_time,
8284            tags: v.tags,
8285        }
8286    }
8287}
8288
8289#[derive(Debug, Clone, Serialize, Deserialize)]
8290pub struct SnapshotImportTaskView {
8291    pub import_task_id: String,
8292    pub status: String,
8293    #[serde(default)]
8294    pub description: Option<String>,
8295    #[serde(default)]
8296    pub disk_image_size: Option<f64>,
8297    #[serde(default)]
8298    pub format: Option<String>,
8299    #[serde(default)]
8300    pub url: Option<String>,
8301    #[serde(default)]
8302    pub user_bucket_s3_bucket: Option<String>,
8303    #[serde(default)]
8304    pub user_bucket_s3_key: Option<String>,
8305    pub owner_id: String,
8306    pub encrypted: bool,
8307    #[serde(default)]
8308    pub kms_key_id: Option<String>,
8309    #[serde(default)]
8310    pub snapshot_id: Option<String>,
8311    #[serde(default)]
8312    pub tags: HashMap<String, String>,
8313}
8314
8315impl From<&SnapshotImportTask> for SnapshotImportTaskView {
8316    fn from(t: &SnapshotImportTask) -> Self {
8317        Self {
8318            import_task_id: t.import_task_id.clone(),
8319            status: t.status.clone(),
8320            description: t.description.clone(),
8321            disk_image_size: t.disk_image_size,
8322            format: t.format.clone(),
8323            url: t.url.clone(),
8324            user_bucket_s3_bucket: t.user_bucket_s3_bucket.clone(),
8325            user_bucket_s3_key: t.user_bucket_s3_key.clone(),
8326            owner_id: t.owner_id.clone(),
8327            encrypted: t.encrypted,
8328            kms_key_id: t.kms_key_id.clone(),
8329            snapshot_id: t.snapshot_id.clone(),
8330            tags: t.tags.clone(),
8331        }
8332    }
8333}
8334
8335impl From<SnapshotImportTaskView> for SnapshotImportTask {
8336    fn from(v: SnapshotImportTaskView) -> Self {
8337        Self {
8338            import_task_id: v.import_task_id,
8339            status: v.status,
8340            description: v.description,
8341            disk_image_size: v.disk_image_size,
8342            format: v.format,
8343            url: v.url,
8344            user_bucket_s3_bucket: v.user_bucket_s3_bucket,
8345            user_bucket_s3_key: v.user_bucket_s3_key,
8346            owner_id: v.owner_id,
8347            encrypted: v.encrypted,
8348            kms_key_id: v.kms_key_id,
8349            snapshot_id: v.snapshot_id,
8350            tags: v.tags,
8351        }
8352    }
8353}
8354
8355#[derive(Debug, Clone, Serialize, Deserialize)]
8356pub struct ImportInstanceVolumeDetailView {
8357    #[serde(default)]
8358    pub availability_zone: Option<String>,
8359    #[serde(default)]
8360    pub bytes_converted: Option<i64>,
8361    #[serde(default)]
8362    pub description: Option<String>,
8363    pub status: String,
8364}
8365
8366impl From<&ImportInstanceVolumeDetail> for ImportInstanceVolumeDetailView {
8367    fn from(v: &ImportInstanceVolumeDetail) -> Self {
8368        Self {
8369            availability_zone: v.availability_zone.clone(),
8370            bytes_converted: v.bytes_converted,
8371            description: v.description.clone(),
8372            status: v.status.clone(),
8373        }
8374    }
8375}
8376
8377impl From<ImportInstanceVolumeDetailView> for ImportInstanceVolumeDetail {
8378    fn from(v: ImportInstanceVolumeDetailView) -> Self {
8379        Self {
8380            availability_zone: v.availability_zone,
8381            bytes_converted: v.bytes_converted,
8382            description: v.description,
8383            status: v.status,
8384        }
8385    }
8386}
8387
8388#[derive(Debug, Clone, Serialize, Deserialize)]
8389pub struct ConversionTaskView {
8390    pub conversion_task_id: String,
8391    pub expiration_time: String,
8392    #[serde(default)]
8393    pub description: Option<String>,
8394    #[serde(default)]
8395    pub instance_id: Option<String>,
8396    pub platform: String,
8397    #[serde(default)]
8398    pub volumes: Vec<ImportInstanceVolumeDetailView>,
8399    pub state: String,
8400    #[serde(default)]
8401    pub status_message: Option<String>,
8402    #[serde(default)]
8403    pub tags: HashMap<String, String>,
8404}
8405
8406impl From<&ConversionTask> for ConversionTaskView {
8407    fn from(t: &ConversionTask) -> Self {
8408        Self {
8409            conversion_task_id: t.conversion_task_id.clone(),
8410            expiration_time: t.expiration_time.clone(),
8411            description: t.description.clone(),
8412            instance_id: t.instance_id.clone(),
8413            platform: t.platform.clone(),
8414            volumes: t
8415                .volumes
8416                .iter()
8417                .map(ImportInstanceVolumeDetailView::from)
8418                .collect(),
8419            state: t.state.clone(),
8420            status_message: t.status_message.clone(),
8421            tags: t.tags.clone(),
8422        }
8423    }
8424}
8425
8426impl From<ConversionTaskView> for ConversionTask {
8427    fn from(v: ConversionTaskView) -> Self {
8428        Self {
8429            conversion_task_id: v.conversion_task_id,
8430            expiration_time: v.expiration_time,
8431            description: v.description,
8432            instance_id: v.instance_id,
8433            platform: v.platform,
8434            volumes: v
8435                .volumes
8436                .into_iter()
8437                .map(ImportInstanceVolumeDetail::from)
8438                .collect(),
8439            state: v.state,
8440            status_message: v.status_message,
8441            tags: v.tags,
8442        }
8443    }
8444}
8445
8446#[derive(Debug, Clone, Serialize, Deserialize)]
8447pub struct ExportTaskView {
8448    pub export_task_id: String,
8449    pub description: String,
8450    pub instance_id: String,
8451    pub target_environment: String,
8452    pub disk_image_format: String,
8453    #[serde(default)]
8454    pub container_format: Option<String>,
8455    pub s3_bucket: String,
8456    #[serde(default)]
8457    pub s3_prefix: Option<String>,
8458    pub s3_key: String,
8459    pub status: String,
8460    #[serde(default)]
8461    pub status_message: Option<String>,
8462    #[serde(default)]
8463    pub tags: HashMap<String, String>,
8464}
8465
8466impl From<&ExportTask> for ExportTaskView {
8467    fn from(t: &ExportTask) -> Self {
8468        Self {
8469            export_task_id: t.export_task_id.clone(),
8470            description: t.description.clone(),
8471            instance_id: t.instance_id.clone(),
8472            target_environment: t.target_environment.clone(),
8473            disk_image_format: t.disk_image_format.clone(),
8474            container_format: t.container_format.clone(),
8475            s3_bucket: t.s3_bucket.clone(),
8476            s3_prefix: t.s3_prefix.clone(),
8477            s3_key: t.s3_key.clone(),
8478            status: t.status.clone(),
8479            status_message: t.status_message.clone(),
8480            tags: t.tags.clone(),
8481        }
8482    }
8483}
8484
8485impl From<ExportTaskView> for ExportTask {
8486    fn from(v: ExportTaskView) -> Self {
8487        Self {
8488            export_task_id: v.export_task_id,
8489            description: v.description,
8490            instance_id: v.instance_id,
8491            target_environment: v.target_environment,
8492            disk_image_format: v.disk_image_format,
8493            container_format: v.container_format,
8494            s3_bucket: v.s3_bucket,
8495            s3_prefix: v.s3_prefix,
8496            s3_key: v.s3_key,
8497            status: v.status,
8498            status_message: v.status_message,
8499            tags: v.tags,
8500        }
8501    }
8502}
8503
8504#[derive(Debug, Clone, Serialize, Deserialize)]
8505pub struct TrunkInterfaceAssociationView {
8506    pub association_id: String,
8507    pub branch_interface_id: String,
8508    pub trunk_interface_id: String,
8509    pub interface_protocol: String,
8510    #[serde(default)]
8511    pub vlan_id: Option<i32>,
8512    #[serde(default)]
8513    pub gre_key: Option<i32>,
8514    #[serde(default)]
8515    pub tags: HashMap<String, String>,
8516}
8517
8518impl From<&TrunkInterfaceAssociation> for TrunkInterfaceAssociationView {
8519    fn from(a: &TrunkInterfaceAssociation) -> Self {
8520        Self {
8521            association_id: a.association_id.clone(),
8522            branch_interface_id: a.branch_interface_id.clone(),
8523            trunk_interface_id: a.trunk_interface_id.clone(),
8524            interface_protocol: a.interface_protocol.clone(),
8525            vlan_id: a.vlan_id,
8526            gre_key: a.gre_key,
8527            tags: a.tags.clone(),
8528        }
8529    }
8530}
8531
8532impl From<TrunkInterfaceAssociationView> for TrunkInterfaceAssociation {
8533    fn from(v: TrunkInterfaceAssociationView) -> Self {
8534        Self {
8535            association_id: v.association_id,
8536            branch_interface_id: v.branch_interface_id,
8537            trunk_interface_id: v.trunk_interface_id,
8538            interface_protocol: v.interface_protocol,
8539            vlan_id: v.vlan_id,
8540            gre_key: v.gre_key,
8541            tags: v.tags,
8542        }
8543    }
8544}
8545
8546#[derive(Debug, Clone, Serialize, Deserialize)]
8547pub struct SecondaryNetworkView {
8548    pub network_id: String,
8549    pub vpc_id: String,
8550    pub primary_cidr_block: String,
8551    #[serde(default)]
8552    pub secondary_cidr_blocks: Vec<String>,
8553    pub state: String,
8554    #[serde(default)]
8555    pub network_border_group: Option<String>,
8556    #[serde(default)]
8557    pub tags: HashMap<String, String>,
8558}
8559
8560impl From<&SecondaryNetwork> for SecondaryNetworkView {
8561    fn from(n: &SecondaryNetwork) -> Self {
8562        Self {
8563            network_id: n.network_id.clone(),
8564            vpc_id: n.vpc_id.clone(),
8565            primary_cidr_block: n.primary_cidr_block.clone(),
8566            secondary_cidr_blocks: n.secondary_cidr_blocks.clone(),
8567            state: n.state.clone(),
8568            network_border_group: n.network_border_group.clone(),
8569            tags: n.tags.clone(),
8570        }
8571    }
8572}
8573
8574impl From<SecondaryNetworkView> for SecondaryNetwork {
8575    fn from(v: SecondaryNetworkView) -> Self {
8576        Self {
8577            network_id: v.network_id,
8578            vpc_id: v.vpc_id,
8579            primary_cidr_block: v.primary_cidr_block,
8580            secondary_cidr_blocks: v.secondary_cidr_blocks,
8581            state: v.state,
8582            network_border_group: v.network_border_group,
8583            tags: v.tags,
8584        }
8585    }
8586}
8587
8588#[derive(Debug, Clone, Serialize, Deserialize)]
8589pub struct SecondarySubnetView {
8590    pub subnet_id: String,
8591    pub vpc_id: String,
8592    pub secondary_network_id: String,
8593    pub cidr_block: String,
8594    pub availability_zone: String,
8595    pub state: String,
8596    #[serde(default)]
8597    pub tags: HashMap<String, String>,
8598}
8599
8600impl From<&SecondarySubnet> for SecondarySubnetView {
8601    fn from(s: &SecondarySubnet) -> Self {
8602        Self {
8603            subnet_id: s.subnet_id.clone(),
8604            vpc_id: s.vpc_id.clone(),
8605            secondary_network_id: s.secondary_network_id.clone(),
8606            cidr_block: s.cidr_block.clone(),
8607            availability_zone: s.availability_zone.clone(),
8608            state: s.state.clone(),
8609            tags: s.tags.clone(),
8610        }
8611    }
8612}
8613
8614impl From<SecondarySubnetView> for SecondarySubnet {
8615    fn from(v: SecondarySubnetView) -> Self {
8616        Self {
8617            subnet_id: v.subnet_id,
8618            vpc_id: v.vpc_id,
8619            secondary_network_id: v.secondary_network_id,
8620            cidr_block: v.cidr_block,
8621            availability_zone: v.availability_zone,
8622            state: v.state,
8623            tags: v.tags,
8624        }
8625    }
8626}
8627
8628// ---------------------------------------------------------------------------
8629// Group 5: View structs + From impls
8630// ---------------------------------------------------------------------------
8631
8632#[derive(Debug, Clone, Serialize, Deserialize)]
8633pub struct ReservedInstancesExchangeView {
8634    pub exchange_id: String,
8635    #[serde(default)]
8636    pub target_reserved_instances_ids: Vec<String>,
8637    #[serde(default)]
8638    pub source_reserved_instances_ids: Vec<String>,
8639    pub status: String,
8640    #[serde(default)]
8641    pub status_message: Option<String>,
8642    pub time: String,
8643}
8644
8645impl From<&crate::types::ReservedInstancesExchange> for ReservedInstancesExchangeView {
8646    fn from(t: &crate::types::ReservedInstancesExchange) -> Self {
8647        Self {
8648            exchange_id: t.exchange_id.clone(),
8649            target_reserved_instances_ids: t.target_reserved_instances_ids.clone(),
8650            source_reserved_instances_ids: t.source_reserved_instances_ids.clone(),
8651            status: t.status.clone(),
8652            status_message: t.status_message.clone(),
8653            time: t.time.clone(),
8654        }
8655    }
8656}
8657
8658impl From<ReservedInstancesExchangeView> for crate::types::ReservedInstancesExchange {
8659    fn from(v: ReservedInstancesExchangeView) -> Self {
8660        Self {
8661            exchange_id: v.exchange_id,
8662            target_reserved_instances_ids: v.target_reserved_instances_ids,
8663            source_reserved_instances_ids: v.source_reserved_instances_ids,
8664            status: v.status,
8665            status_message: v.status_message,
8666            time: v.time,
8667        }
8668    }
8669}
8670
8671#[derive(Debug, Clone, Serialize, Deserialize)]
8672pub struct PriceScheduleView {
8673    pub term: i64,
8674    pub price: f64,
8675    pub currency_code: String,
8676    pub active: bool,
8677}
8678
8679impl From<&crate::types::PriceSchedule> for PriceScheduleView {
8680    fn from(p: &crate::types::PriceSchedule) -> Self {
8681        Self {
8682            term: p.term,
8683            price: p.price,
8684            currency_code: p.currency_code.clone(),
8685            active: p.active,
8686        }
8687    }
8688}
8689
8690impl From<PriceScheduleView> for crate::types::PriceSchedule {
8691    fn from(v: PriceScheduleView) -> Self {
8692        Self {
8693            term: v.term,
8694            price: v.price,
8695            currency_code: v.currency_code,
8696            active: v.active,
8697        }
8698    }
8699}
8700
8701#[derive(Debug, Clone, Serialize, Deserialize)]
8702pub struct ReservedInstancesListingView {
8703    pub listing_id: String,
8704    pub reserved_instances_id: String,
8705    pub instance_count: i32,
8706    #[serde(default)]
8707    pub price_schedules: Vec<PriceScheduleView>,
8708    pub status: String,
8709    #[serde(default)]
8710    pub status_message: Option<String>,
8711    pub create_date: String,
8712    pub update_date: String,
8713    #[serde(default)]
8714    pub client_token: Option<String>,
8715    #[serde(default)]
8716    pub tags: HashMap<String, String>,
8717}
8718
8719impl From<&crate::types::ReservedInstancesListing> for ReservedInstancesListingView {
8720    fn from(t: &crate::types::ReservedInstancesListing) -> Self {
8721        Self {
8722            listing_id: t.listing_id.clone(),
8723            reserved_instances_id: t.reserved_instances_id.clone(),
8724            instance_count: t.instance_count,
8725            price_schedules: t
8726                .price_schedules
8727                .iter()
8728                .map(PriceScheduleView::from)
8729                .collect(),
8730            status: t.status.clone(),
8731            status_message: t.status_message.clone(),
8732            create_date: t.create_date.clone(),
8733            update_date: t.update_date.clone(),
8734            client_token: t.client_token.clone(),
8735            tags: t.tags.clone(),
8736        }
8737    }
8738}
8739
8740impl From<ReservedInstancesListingView> for crate::types::ReservedInstancesListing {
8741    fn from(v: ReservedInstancesListingView) -> Self {
8742        Self {
8743            listing_id: v.listing_id,
8744            reserved_instances_id: v.reserved_instances_id,
8745            instance_count: v.instance_count,
8746            price_schedules: v
8747                .price_schedules
8748                .into_iter()
8749                .map(crate::types::PriceSchedule::from)
8750                .collect(),
8751            status: v.status,
8752            status_message: v.status_message,
8753            create_date: v.create_date,
8754            update_date: v.update_date,
8755            client_token: v.client_token,
8756            tags: v.tags,
8757        }
8758    }
8759}
8760
8761#[derive(Debug, Clone, Serialize, Deserialize)]
8762pub struct ReservedInstancesPurchaseView {
8763    pub purchase_id: String,
8764    pub reserved_instances_offering_id: String,
8765    pub instance_count: i32,
8766    #[serde(default)]
8767    pub limit_price: Option<String>,
8768    pub purchase_time: String,
8769    #[serde(default)]
8770    pub tags: HashMap<String, String>,
8771    #[serde(default)]
8772    pub queued: bool,
8773    #[serde(default)]
8774    pub reserved_instances_id: Option<String>,
8775}
8776
8777impl From<&crate::types::ReservedInstancesPurchase> for ReservedInstancesPurchaseView {
8778    fn from(t: &crate::types::ReservedInstancesPurchase) -> Self {
8779        Self {
8780            purchase_id: t.purchase_id.clone(),
8781            reserved_instances_offering_id: t.reserved_instances_offering_id.clone(),
8782            instance_count: t.instance_count,
8783            limit_price: t.limit_price.clone(),
8784            purchase_time: t.purchase_time.clone(),
8785            tags: t.tags.clone(),
8786            queued: t.queued,
8787            reserved_instances_id: t.reserved_instances_id.clone(),
8788        }
8789    }
8790}
8791
8792impl From<ReservedInstancesPurchaseView> for crate::types::ReservedInstancesPurchase {
8793    fn from(v: ReservedInstancesPurchaseView) -> Self {
8794        Self {
8795            purchase_id: v.purchase_id,
8796            reserved_instances_offering_id: v.reserved_instances_offering_id,
8797            instance_count: v.instance_count,
8798            limit_price: v.limit_price,
8799            purchase_time: v.purchase_time,
8800            tags: v.tags,
8801            queued: v.queued,
8802            reserved_instances_id: v.reserved_instances_id,
8803        }
8804    }
8805}
8806
8807#[derive(Debug, Clone, Serialize, Deserialize)]
8808pub struct ReservedInstancesRecordView {
8809    pub reserved_instances_id: String,
8810    pub instance_type: String,
8811    pub instance_count: i32,
8812    pub product_description: String,
8813    pub scope: String,
8814    pub currency_code: String,
8815    pub duration: i64,
8816    pub fixed_price: f64,
8817    pub usage_price: f64,
8818    pub offering_class: String,
8819    pub offering_type: String,
8820    pub instance_tenancy: String,
8821    pub start: String,
8822    pub end: String,
8823    pub state: String,
8824    #[serde(default)]
8825    pub tags: HashMap<String, String>,
8826}
8827
8828impl From<&crate::types::ReservedInstances> for ReservedInstancesRecordView {
8829    fn from(t: &crate::types::ReservedInstances) -> Self {
8830        Self {
8831            reserved_instances_id: t.reserved_instances_id.clone(),
8832            instance_type: t.instance_type.clone(),
8833            instance_count: t.instance_count,
8834            product_description: t.product_description.clone(),
8835            scope: t.scope.clone(),
8836            currency_code: t.currency_code.clone(),
8837            duration: t.duration,
8838            fixed_price: t.fixed_price,
8839            usage_price: t.usage_price,
8840            offering_class: t.offering_class.clone(),
8841            offering_type: t.offering_type.clone(),
8842            instance_tenancy: t.instance_tenancy.clone(),
8843            start: t.start.clone(),
8844            end: t.end.clone(),
8845            state: t.state.clone(),
8846            tags: t.tags.clone(),
8847        }
8848    }
8849}
8850
8851impl From<ReservedInstancesRecordView> for crate::types::ReservedInstances {
8852    fn from(v: ReservedInstancesRecordView) -> Self {
8853        Self {
8854            reserved_instances_id: v.reserved_instances_id,
8855            instance_type: v.instance_type,
8856            instance_count: v.instance_count,
8857            product_description: v.product_description,
8858            scope: v.scope,
8859            currency_code: v.currency_code,
8860            duration: v.duration,
8861            fixed_price: v.fixed_price,
8862            usage_price: v.usage_price,
8863            offering_class: v.offering_class,
8864            offering_type: v.offering_type,
8865            instance_tenancy: v.instance_tenancy,
8866            start: v.start,
8867            end: v.end,
8868            state: v.state,
8869            tags: v.tags,
8870        }
8871    }
8872}
8873
8874#[derive(Debug, Clone, Serialize, Deserialize)]
8875pub struct ReservedInstancesConfigurationView {
8876    #[serde(default)]
8877    pub availability_zone: Option<String>,
8878    #[serde(default)]
8879    pub instance_count: Option<i32>,
8880    #[serde(default)]
8881    pub instance_type: Option<String>,
8882    #[serde(default)]
8883    pub platform: Option<String>,
8884    #[serde(default)]
8885    pub scope: Option<String>,
8886}
8887
8888impl From<&crate::types::ReservedInstancesConfiguration> for ReservedInstancesConfigurationView {
8889    fn from(c: &crate::types::ReservedInstancesConfiguration) -> Self {
8890        Self {
8891            availability_zone: c.availability_zone.clone(),
8892            instance_count: c.instance_count,
8893            instance_type: c.instance_type.clone(),
8894            platform: c.platform.clone(),
8895            scope: c.scope.clone(),
8896        }
8897    }
8898}
8899
8900impl From<ReservedInstancesConfigurationView> for crate::types::ReservedInstancesConfiguration {
8901    fn from(v: ReservedInstancesConfigurationView) -> Self {
8902        Self {
8903            availability_zone: v.availability_zone,
8904            instance_count: v.instance_count,
8905            instance_type: v.instance_type,
8906            platform: v.platform,
8907            scope: v.scope,
8908        }
8909    }
8910}
8911
8912#[derive(Debug, Clone, Serialize, Deserialize)]
8913pub struct ReservedInstancesModificationView {
8914    pub modification_id: String,
8915    #[serde(default)]
8916    pub reserved_instances_ids: Vec<String>,
8917    #[serde(default)]
8918    pub target_configurations: Vec<ReservedInstancesConfigurationView>,
8919    pub status: String,
8920    #[serde(default)]
8921    pub status_message: Option<String>,
8922    pub create_date: String,
8923    pub update_date: String,
8924    pub effective_date: String,
8925    #[serde(default)]
8926    pub client_token: Option<String>,
8927}
8928
8929impl From<&crate::types::ReservedInstancesModification> for ReservedInstancesModificationView {
8930    fn from(m: &crate::types::ReservedInstancesModification) -> Self {
8931        Self {
8932            modification_id: m.modification_id.clone(),
8933            reserved_instances_ids: m.reserved_instances_ids.clone(),
8934            target_configurations: m
8935                .target_configurations
8936                .iter()
8937                .map(ReservedInstancesConfigurationView::from)
8938                .collect(),
8939            status: m.status.clone(),
8940            status_message: m.status_message.clone(),
8941            create_date: m.create_date.clone(),
8942            update_date: m.update_date.clone(),
8943            effective_date: m.effective_date.clone(),
8944            client_token: m.client_token.clone(),
8945        }
8946    }
8947}
8948
8949impl From<ReservedInstancesModificationView> for crate::types::ReservedInstancesModification {
8950    fn from(v: ReservedInstancesModificationView) -> Self {
8951        Self {
8952            modification_id: v.modification_id,
8953            reserved_instances_ids: v.reserved_instances_ids,
8954            target_configurations: v
8955                .target_configurations
8956                .into_iter()
8957                .map(crate::types::ReservedInstancesConfiguration::from)
8958                .collect(),
8959            status: v.status,
8960            status_message: v.status_message,
8961            create_date: v.create_date,
8962            update_date: v.update_date,
8963            effective_date: v.effective_date,
8964            client_token: v.client_token,
8965        }
8966    }
8967}
8968
8969#[derive(Debug, Clone, Serialize, Deserialize)]
8970pub struct FpgaImageView {
8971    pub fpga_image_id: String,
8972    pub fpga_image_global_id: String,
8973    pub name: String,
8974    #[serde(default)]
8975    pub description: Option<String>,
8976    #[serde(default)]
8977    pub shell_version: Option<String>,
8978    #[serde(default)]
8979    pub pci_id_vendor: Option<String>,
8980    #[serde(default)]
8981    pub pci_id_device: Option<String>,
8982    pub state: String,
8983    pub create_time: String,
8984    pub update_time: String,
8985    pub owner_id: String,
8986    #[serde(default)]
8987    pub owner_alias: Option<String>,
8988    #[serde(default)]
8989    pub product_codes: Vec<(String, String)>,
8990    #[serde(default)]
8991    pub tags: HashMap<String, String>,
8992    pub public: bool,
8993    pub data_retention_support: bool,
8994    #[serde(default)]
8995    pub instance_types: Vec<String>,
8996    #[serde(default)]
8997    pub load_permissions: Vec<(String, String)>,
8998}
8999
9000impl From<&crate::types::FpgaImage> for FpgaImageView {
9001    fn from(t: &crate::types::FpgaImage) -> Self {
9002        Self {
9003            fpga_image_id: t.fpga_image_id.clone(),
9004            fpga_image_global_id: t.fpga_image_global_id.clone(),
9005            name: t.name.clone(),
9006            description: t.description.clone(),
9007            shell_version: t.shell_version.clone(),
9008            pci_id_vendor: t.pci_id_vendor.clone(),
9009            pci_id_device: t.pci_id_device.clone(),
9010            state: t.state.clone(),
9011            create_time: t.create_time.clone(),
9012            update_time: t.update_time.clone(),
9013            owner_id: t.owner_id.clone(),
9014            owner_alias: t.owner_alias.clone(),
9015            product_codes: t.product_codes.clone(),
9016            tags: t.tags.clone(),
9017            public: t.public,
9018            data_retention_support: t.data_retention_support,
9019            instance_types: t.instance_types.clone(),
9020            load_permissions: t.load_permissions.clone(),
9021        }
9022    }
9023}
9024
9025impl From<FpgaImageView> for crate::types::FpgaImage {
9026    fn from(v: FpgaImageView) -> Self {
9027        Self {
9028            fpga_image_id: v.fpga_image_id,
9029            fpga_image_global_id: v.fpga_image_global_id,
9030            name: v.name,
9031            description: v.description,
9032            shell_version: v.shell_version,
9033            pci_id_vendor: v.pci_id_vendor,
9034            pci_id_device: v.pci_id_device,
9035            state: v.state,
9036            create_time: v.create_time,
9037            update_time: v.update_time,
9038            owner_id: v.owner_id,
9039            owner_alias: v.owner_alias,
9040            product_codes: v.product_codes,
9041            tags: v.tags,
9042            public: v.public,
9043            data_retention_support: v.data_retention_support,
9044            instance_types: v.instance_types,
9045            load_permissions: v.load_permissions,
9046        }
9047    }
9048}
9049
9050#[derive(Debug, Clone, Serialize, Deserialize)]
9051pub struct ImageUsageReportView {
9052    pub report_id: String,
9053    pub image_id: String,
9054    #[serde(default)]
9055    pub account_filters: Vec<String>,
9056    #[serde(default)]
9057    pub resource_types: Vec<String>,
9058    pub status: String,
9059    pub creation_time: String,
9060    #[serde(default)]
9061    pub completion_time: Option<String>,
9062    #[serde(default)]
9063    pub tags: HashMap<String, String>,
9064}
9065
9066impl From<&crate::types::ImageUsageReport> for ImageUsageReportView {
9067    fn from(t: &crate::types::ImageUsageReport) -> Self {
9068        Self {
9069            report_id: t.report_id.clone(),
9070            image_id: t.image_id.clone(),
9071            account_filters: t.account_filters.clone(),
9072            resource_types: t.resource_types.clone(),
9073            status: t.status.clone(),
9074            creation_time: t.creation_time.clone(),
9075            completion_time: t.completion_time.clone(),
9076            tags: t.tags.clone(),
9077        }
9078    }
9079}
9080
9081impl From<ImageUsageReportView> for crate::types::ImageUsageReport {
9082    fn from(v: ImageUsageReportView) -> Self {
9083        Self {
9084            report_id: v.report_id,
9085            image_id: v.image_id,
9086            account_filters: v.account_filters,
9087            resource_types: v.resource_types,
9088            status: v.status,
9089            creation_time: v.creation_time,
9090            completion_time: v.completion_time,
9091            tags: v.tags,
9092        }
9093    }
9094}
9095
9096#[derive(Debug, Clone, Serialize, Deserialize)]
9097pub struct RestoreImageTaskView {
9098    pub image_id: String,
9099    pub name: String,
9100    pub s3_object_url: String,
9101    pub status: String,
9102    #[serde(default)]
9103    pub status_message: Option<String>,
9104    pub creation_time: String,
9105}
9106
9107impl From<&crate::types::RestoreImageTask> for RestoreImageTaskView {
9108    fn from(t: &crate::types::RestoreImageTask) -> Self {
9109        Self {
9110            image_id: t.image_id.clone(),
9111            name: t.name.clone(),
9112            s3_object_url: t.s3_object_url.clone(),
9113            status: t.status.clone(),
9114            status_message: t.status_message.clone(),
9115            creation_time: t.creation_time.clone(),
9116        }
9117    }
9118}
9119
9120impl From<RestoreImageTaskView> for crate::types::RestoreImageTask {
9121    fn from(v: RestoreImageTaskView) -> Self {
9122        Self {
9123            image_id: v.image_id,
9124            name: v.name,
9125            s3_object_url: v.s3_object_url,
9126            status: v.status,
9127            status_message: v.status_message,
9128            creation_time: v.creation_time,
9129        }
9130    }
9131}
9132
9133#[derive(Debug, Clone, Serialize, Deserialize)]
9134pub struct StoreImageTaskView {
9135    pub image_id: String,
9136    pub ami_id: String,
9137    pub bucket: String,
9138    pub s3_object_key: String,
9139    pub store_task_state: String,
9140    #[serde(default)]
9141    pub store_task_failure_reason: Option<String>,
9142    pub progress_percentage: i32,
9143    pub task_start_time: String,
9144}
9145
9146impl From<&crate::types::StoreImageTask> for StoreImageTaskView {
9147    fn from(t: &crate::types::StoreImageTask) -> Self {
9148        Self {
9149            image_id: t.image_id.clone(),
9150            ami_id: t.ami_id.clone(),
9151            bucket: t.bucket.clone(),
9152            s3_object_key: t.s3_object_key.clone(),
9153            store_task_state: t.store_task_state.clone(),
9154            store_task_failure_reason: t.store_task_failure_reason.clone(),
9155            progress_percentage: t.progress_percentage,
9156            task_start_time: t.task_start_time.clone(),
9157        }
9158    }
9159}
9160
9161impl From<StoreImageTaskView> for crate::types::StoreImageTask {
9162    fn from(v: StoreImageTaskView) -> Self {
9163        Self {
9164            image_id: v.image_id,
9165            ami_id: v.ami_id,
9166            bucket: v.bucket,
9167            s3_object_key: v.s3_object_key,
9168            store_task_state: v.store_task_state,
9169            store_task_failure_reason: v.store_task_failure_reason,
9170            progress_percentage: v.progress_percentage,
9171            task_start_time: v.task_start_time,
9172        }
9173    }
9174}
9175
9176#[derive(Debug, Clone, Serialize, Deserialize)]
9177pub struct ImportImageSnapshotDetailView {
9178    #[serde(default)]
9179    pub disk_image_size: Option<f64>,
9180    #[serde(default)]
9181    pub format: Option<String>,
9182    #[serde(default)]
9183    pub progress: Option<String>,
9184    #[serde(default)]
9185    pub snapshot_id: Option<String>,
9186    #[serde(default)]
9187    pub status: Option<String>,
9188    #[serde(default)]
9189    pub url: Option<String>,
9190    #[serde(default)]
9191    pub user_bucket_s3_bucket: Option<String>,
9192    #[serde(default)]
9193    pub user_bucket_s3_key: Option<String>,
9194}
9195
9196impl From<&crate::types::ImportImageSnapshotDetail> for ImportImageSnapshotDetailView {
9197    fn from(s: &crate::types::ImportImageSnapshotDetail) -> Self {
9198        Self {
9199            disk_image_size: s.disk_image_size,
9200            format: s.format.clone(),
9201            progress: s.progress.clone(),
9202            snapshot_id: s.snapshot_id.clone(),
9203            status: s.status.clone(),
9204            url: s.url.clone(),
9205            user_bucket_s3_bucket: s.user_bucket_s3_bucket.clone(),
9206            user_bucket_s3_key: s.user_bucket_s3_key.clone(),
9207        }
9208    }
9209}
9210
9211impl From<ImportImageSnapshotDetailView> for crate::types::ImportImageSnapshotDetail {
9212    fn from(v: ImportImageSnapshotDetailView) -> Self {
9213        Self {
9214            disk_image_size: v.disk_image_size,
9215            format: v.format,
9216            progress: v.progress,
9217            snapshot_id: v.snapshot_id,
9218            status: v.status,
9219            url: v.url,
9220            user_bucket_s3_bucket: v.user_bucket_s3_bucket,
9221            user_bucket_s3_key: v.user_bucket_s3_key,
9222        }
9223    }
9224}
9225
9226#[derive(Debug, Clone, Serialize, Deserialize)]
9227pub struct ImportImageTaskView {
9228    pub import_task_id: String,
9229    #[serde(default)]
9230    pub architecture: Option<String>,
9231    #[serde(default)]
9232    pub description: Option<String>,
9233    pub encrypted: bool,
9234    #[serde(default)]
9235    pub hypervisor: Option<String>,
9236    #[serde(default)]
9237    pub image_id: Option<String>,
9238    #[serde(default)]
9239    pub license_type: Option<String>,
9240    #[serde(default)]
9241    pub platform: Option<String>,
9242    #[serde(default)]
9243    pub progress: Option<String>,
9244    #[serde(default)]
9245    pub snapshot_details: Vec<ImportImageSnapshotDetailView>,
9246    pub status: String,
9247    #[serde(default)]
9248    pub status_message: Option<String>,
9249    #[serde(default)]
9250    pub tags: HashMap<String, String>,
9251    #[serde(default)]
9252    pub usage_operation: Option<String>,
9253    #[serde(default)]
9254    pub boot_mode: Option<String>,
9255}
9256
9257impl From<&crate::types::ImportImageTask> for ImportImageTaskView {
9258    fn from(t: &crate::types::ImportImageTask) -> Self {
9259        Self {
9260            import_task_id: t.import_task_id.clone(),
9261            architecture: t.architecture.clone(),
9262            description: t.description.clone(),
9263            encrypted: t.encrypted,
9264            hypervisor: t.hypervisor.clone(),
9265            image_id: t.image_id.clone(),
9266            license_type: t.license_type.clone(),
9267            platform: t.platform.clone(),
9268            progress: t.progress.clone(),
9269            snapshot_details: t
9270                .snapshot_details
9271                .iter()
9272                .map(ImportImageSnapshotDetailView::from)
9273                .collect(),
9274            status: t.status.clone(),
9275            status_message: t.status_message.clone(),
9276            tags: t.tags.clone(),
9277            usage_operation: t.usage_operation.clone(),
9278            boot_mode: t.boot_mode.clone(),
9279        }
9280    }
9281}
9282
9283impl From<ImportImageTaskView> for crate::types::ImportImageTask {
9284    fn from(v: ImportImageTaskView) -> Self {
9285        Self {
9286            import_task_id: v.import_task_id,
9287            architecture: v.architecture,
9288            description: v.description,
9289            encrypted: v.encrypted,
9290            hypervisor: v.hypervisor,
9291            image_id: v.image_id,
9292            license_type: v.license_type,
9293            platform: v.platform,
9294            progress: v.progress,
9295            snapshot_details: v
9296                .snapshot_details
9297                .into_iter()
9298                .map(crate::types::ImportImageSnapshotDetail::from)
9299                .collect(),
9300            status: v.status,
9301            status_message: v.status_message,
9302            tags: v.tags,
9303            usage_operation: v.usage_operation,
9304            boot_mode: v.boot_mode,
9305        }
9306    }
9307}
9308
9309#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9310pub struct AllowedImageCriterionView {
9311    #[serde(default)]
9312    pub image_providers: Vec<String>,
9313    #[serde(default)]
9314    pub marketplace_product_codes: Vec<String>,
9315    #[serde(default)]
9316    pub deprecation_time_condition: Option<String>,
9317}
9318
9319impl From<&crate::types::AllowedImageCriterion> for AllowedImageCriterionView {
9320    fn from(c: &crate::types::AllowedImageCriterion) -> Self {
9321        Self {
9322            image_providers: c.image_providers.clone(),
9323            marketplace_product_codes: c.marketplace_product_codes.clone(),
9324            deprecation_time_condition: c.deprecation_time_condition.clone(),
9325        }
9326    }
9327}
9328
9329impl From<AllowedImageCriterionView> for crate::types::AllowedImageCriterion {
9330    fn from(v: AllowedImageCriterionView) -> Self {
9331        Self {
9332            image_providers: v.image_providers,
9333            marketplace_product_codes: v.marketplace_product_codes,
9334            deprecation_time_condition: v.deprecation_time_condition,
9335        }
9336    }
9337}
9338
9339#[derive(Debug, Clone, Serialize, Deserialize)]
9340pub struct InstanceEventWindowTimeRangeView {
9341    #[serde(default)]
9342    pub start_week_day: Option<String>,
9343    #[serde(default)]
9344    pub start_hour: Option<i32>,
9345    #[serde(default)]
9346    pub end_week_day: Option<String>,
9347    #[serde(default)]
9348    pub end_hour: Option<i32>,
9349}
9350
9351impl From<&crate::types::InstanceEventWindowTimeRange> for InstanceEventWindowTimeRangeView {
9352    fn from(t: &crate::types::InstanceEventWindowTimeRange) -> Self {
9353        Self {
9354            start_week_day: t.start_week_day.clone(),
9355            start_hour: t.start_hour,
9356            end_week_day: t.end_week_day.clone(),
9357            end_hour: t.end_hour,
9358        }
9359    }
9360}
9361
9362impl From<InstanceEventWindowTimeRangeView> for crate::types::InstanceEventWindowTimeRange {
9363    fn from(v: InstanceEventWindowTimeRangeView) -> Self {
9364        Self {
9365            start_week_day: v.start_week_day,
9366            start_hour: v.start_hour,
9367            end_week_day: v.end_week_day,
9368            end_hour: v.end_hour,
9369        }
9370    }
9371}
9372
9373#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9374pub struct InstanceEventWindowAssociationView {
9375    #[serde(default)]
9376    pub instance_ids: Vec<String>,
9377    #[serde(default)]
9378    pub dedicated_host_ids: Vec<String>,
9379    #[serde(default)]
9380    pub tags: Vec<(String, String)>,
9381}
9382
9383impl From<&crate::types::InstanceEventWindowAssociation> for InstanceEventWindowAssociationView {
9384    fn from(t: &crate::types::InstanceEventWindowAssociation) -> Self {
9385        Self {
9386            instance_ids: t.instance_ids.clone(),
9387            dedicated_host_ids: t.dedicated_host_ids.clone(),
9388            tags: t.tags.clone(),
9389        }
9390    }
9391}
9392
9393impl From<InstanceEventWindowAssociationView> for crate::types::InstanceEventWindowAssociation {
9394    fn from(v: InstanceEventWindowAssociationView) -> Self {
9395        Self {
9396            instance_ids: v.instance_ids,
9397            dedicated_host_ids: v.dedicated_host_ids,
9398            tags: v.tags,
9399        }
9400    }
9401}
9402
9403#[derive(Debug, Clone, Serialize, Deserialize)]
9404pub struct InstanceEventWindowView {
9405    pub instance_event_window_id: String,
9406    pub name: String,
9407    #[serde(default)]
9408    pub time_ranges: Vec<InstanceEventWindowTimeRangeView>,
9409    #[serde(default)]
9410    pub cron_expression: Option<String>,
9411    #[serde(default)]
9412    pub association_target: Option<InstanceEventWindowAssociationView>,
9413    pub state: String,
9414    #[serde(default)]
9415    pub tags: HashMap<String, String>,
9416}
9417
9418impl From<&crate::types::InstanceEventWindow> for InstanceEventWindowView {
9419    fn from(t: &crate::types::InstanceEventWindow) -> Self {
9420        Self {
9421            instance_event_window_id: t.instance_event_window_id.clone(),
9422            name: t.name.clone(),
9423            time_ranges: t
9424                .time_ranges
9425                .iter()
9426                .map(InstanceEventWindowTimeRangeView::from)
9427                .collect(),
9428            cron_expression: t.cron_expression.clone(),
9429            association_target: t
9430                .association_target
9431                .as_ref()
9432                .map(InstanceEventWindowAssociationView::from),
9433            state: t.state.clone(),
9434            tags: t.tags.clone(),
9435        }
9436    }
9437}
9438
9439impl From<InstanceEventWindowView> for crate::types::InstanceEventWindow {
9440    fn from(v: InstanceEventWindowView) -> Self {
9441        Self {
9442            instance_event_window_id: v.instance_event_window_id,
9443            name: v.name,
9444            time_ranges: v
9445                .time_ranges
9446                .into_iter()
9447                .map(crate::types::InstanceEventWindowTimeRange::from)
9448                .collect(),
9449            cron_expression: v.cron_expression,
9450            association_target: v
9451                .association_target
9452                .map(crate::types::InstanceEventWindowAssociation::from),
9453            state: v.state,
9454            tags: v.tags,
9455        }
9456    }
9457}
9458
9459#[derive(Debug, Clone, Serialize, Deserialize)]
9460pub struct InstanceEventView {
9461    pub event_id: String,
9462    pub instance_id: String,
9463    pub code: String,
9464    pub description: String,
9465    pub not_before: String,
9466    pub not_after: String,
9467    #[serde(default)]
9468    pub not_before_deadline: Option<String>,
9469}
9470
9471impl From<&crate::types::InstanceEvent> for InstanceEventView {
9472    fn from(t: &crate::types::InstanceEvent) -> Self {
9473        Self {
9474            event_id: t.event_id.clone(),
9475            instance_id: t.instance_id.clone(),
9476            code: t.code.clone(),
9477            description: t.description.clone(),
9478            not_before: t.not_before.clone(),
9479            not_after: t.not_after.clone(),
9480            not_before_deadline: t.not_before_deadline.clone(),
9481        }
9482    }
9483}
9484
9485impl From<InstanceEventView> for crate::types::InstanceEvent {
9486    fn from(v: InstanceEventView) -> Self {
9487        Self {
9488            event_id: v.event_id,
9489            instance_id: v.instance_id,
9490            code: v.code,
9491            description: v.description,
9492            not_before: v.not_before,
9493            not_after: v.not_after,
9494            not_before_deadline: v.not_before_deadline,
9495        }
9496    }
9497}
9498
9499#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9500pub struct InstanceTagNotificationAttributesView {
9501    #[serde(default)]
9502    pub include_all_tags_of_instance: bool,
9503    #[serde(default)]
9504    pub instance_tag_keys: Vec<String>,
9505}
9506
9507impl From<&crate::types::InstanceTagNotificationAttributes>
9508    for InstanceTagNotificationAttributesView
9509{
9510    fn from(t: &crate::types::InstanceTagNotificationAttributes) -> Self {
9511        Self {
9512            include_all_tags_of_instance: t.include_all_tags_of_instance,
9513            instance_tag_keys: t.instance_tag_keys.clone(),
9514        }
9515    }
9516}
9517
9518impl From<InstanceTagNotificationAttributesView>
9519    for crate::types::InstanceTagNotificationAttributes
9520{
9521    fn from(v: InstanceTagNotificationAttributesView) -> Self {
9522        Self {
9523            include_all_tags_of_instance: v.include_all_tags_of_instance,
9524            instance_tag_keys: v.instance_tag_keys,
9525        }
9526    }
9527}
9528
9529#[derive(Debug, Clone, Serialize, Deserialize)]
9530pub struct HostReservationView {
9531    pub host_reservation_id: String,
9532    #[serde(default)]
9533    pub host_id_set: Vec<String>,
9534    pub currency_code: String,
9535    pub duration: i32,
9536    #[serde(default)]
9537    pub end: Option<String>,
9538    pub hourly_price: String,
9539    pub instance_family: String,
9540    pub offering_id: String,
9541    pub payment_option: String,
9542    pub start: String,
9543    pub state: String,
9544    pub upfront_price: String,
9545    #[serde(default)]
9546    pub tags: HashMap<String, String>,
9547}
9548
9549impl From<&crate::types::HostReservation> for HostReservationView {
9550    fn from(t: &crate::types::HostReservation) -> Self {
9551        Self {
9552            host_reservation_id: t.host_reservation_id.clone(),
9553            host_id_set: t.host_id_set.clone(),
9554            currency_code: t.currency_code.clone(),
9555            duration: t.duration,
9556            end: t.end.clone(),
9557            hourly_price: t.hourly_price.clone(),
9558            instance_family: t.instance_family.clone(),
9559            offering_id: t.offering_id.clone(),
9560            payment_option: t.payment_option.clone(),
9561            start: t.start.clone(),
9562            state: t.state.clone(),
9563            upfront_price: t.upfront_price.clone(),
9564            tags: t.tags.clone(),
9565        }
9566    }
9567}
9568
9569impl From<HostReservationView> for crate::types::HostReservation {
9570    fn from(v: HostReservationView) -> Self {
9571        Self {
9572            host_reservation_id: v.host_reservation_id,
9573            host_id_set: v.host_id_set,
9574            currency_code: v.currency_code,
9575            duration: v.duration,
9576            end: v.end,
9577            hourly_price: v.hourly_price,
9578            instance_family: v.instance_family,
9579            offering_id: v.offering_id,
9580            payment_option: v.payment_option,
9581            start: v.start,
9582            state: v.state,
9583            upfront_price: v.upfront_price,
9584            tags: v.tags,
9585        }
9586    }
9587}
9588
9589#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9590pub struct ScheduledInstanceRecurrenceView {
9591    #[serde(default)]
9592    pub frequency: Option<String>,
9593    #[serde(default)]
9594    pub interval: Option<i32>,
9595    #[serde(default)]
9596    pub occurrence_day_set: Vec<i32>,
9597    #[serde(default)]
9598    pub occurrence_relative_to_end: Option<bool>,
9599    #[serde(default)]
9600    pub occurrence_unit: Option<String>,
9601}
9602
9603impl From<&crate::types::ScheduledInstanceRecurrence> for ScheduledInstanceRecurrenceView {
9604    fn from(t: &crate::types::ScheduledInstanceRecurrence) -> Self {
9605        Self {
9606            frequency: t.frequency.clone(),
9607            interval: t.interval,
9608            occurrence_day_set: t.occurrence_day_set.clone(),
9609            occurrence_relative_to_end: t.occurrence_relative_to_end,
9610            occurrence_unit: t.occurrence_unit.clone(),
9611        }
9612    }
9613}
9614
9615impl From<ScheduledInstanceRecurrenceView> for crate::types::ScheduledInstanceRecurrence {
9616    fn from(v: ScheduledInstanceRecurrenceView) -> Self {
9617        Self {
9618            frequency: v.frequency,
9619            interval: v.interval,
9620            occurrence_day_set: v.occurrence_day_set,
9621            occurrence_relative_to_end: v.occurrence_relative_to_end,
9622            occurrence_unit: v.occurrence_unit,
9623        }
9624    }
9625}
9626
9627#[derive(Debug, Clone, Serialize, Deserialize)]
9628pub struct ScheduledInstanceView {
9629    pub scheduled_instance_id: String,
9630    pub instance_type: String,
9631    pub platform: String,
9632    pub network_platform: String,
9633    pub availability_zone: String,
9634    pub instance_count: i32,
9635    pub hourly_price: String,
9636    pub total_scheduled_instance_hours: i32,
9637    pub term_start_date: String,
9638    pub term_end_date: String,
9639    pub recurrence: ScheduledInstanceRecurrenceView,
9640    pub slot_duration_in_hours: i32,
9641    #[serde(default)]
9642    pub previous_slot_end_time: Option<String>,
9643    #[serde(default)]
9644    pub next_slot_start_time: Option<String>,
9645    pub create_date: String,
9646}
9647
9648impl From<&crate::types::ScheduledInstance> for ScheduledInstanceView {
9649    fn from(t: &crate::types::ScheduledInstance) -> Self {
9650        Self {
9651            scheduled_instance_id: t.scheduled_instance_id.clone(),
9652            instance_type: t.instance_type.clone(),
9653            platform: t.platform.clone(),
9654            network_platform: t.network_platform.clone(),
9655            availability_zone: t.availability_zone.clone(),
9656            instance_count: t.instance_count,
9657            hourly_price: t.hourly_price.clone(),
9658            total_scheduled_instance_hours: t.total_scheduled_instance_hours,
9659            term_start_date: t.term_start_date.clone(),
9660            term_end_date: t.term_end_date.clone(),
9661            recurrence: ScheduledInstanceRecurrenceView::from(&t.recurrence),
9662            slot_duration_in_hours: t.slot_duration_in_hours,
9663            previous_slot_end_time: t.previous_slot_end_time.clone(),
9664            next_slot_start_time: t.next_slot_start_time.clone(),
9665            create_date: t.create_date.clone(),
9666        }
9667    }
9668}
9669
9670impl From<ScheduledInstanceView> for crate::types::ScheduledInstance {
9671    fn from(v: ScheduledInstanceView) -> Self {
9672        Self {
9673            scheduled_instance_id: v.scheduled_instance_id,
9674            instance_type: v.instance_type,
9675            platform: v.platform,
9676            network_platform: v.network_platform,
9677            availability_zone: v.availability_zone,
9678            instance_count: v.instance_count,
9679            hourly_price: v.hourly_price,
9680            total_scheduled_instance_hours: v.total_scheduled_instance_hours,
9681            term_start_date: v.term_start_date,
9682            term_end_date: v.term_end_date,
9683            recurrence: crate::types::ScheduledInstanceRecurrence::from(v.recurrence),
9684            slot_duration_in_hours: v.slot_duration_in_hours,
9685            previous_slot_end_time: v.previous_slot_end_time,
9686            next_slot_start_time: v.next_slot_start_time,
9687            create_date: v.create_date,
9688        }
9689    }
9690}
9691
9692#[derive(Debug, Clone, Serialize, Deserialize)]
9693pub struct InstanceStatusReportView {
9694    pub instance_id: String,
9695    pub status: String,
9696    #[serde(default)]
9697    pub reason_codes: Vec<String>,
9698    #[serde(default)]
9699    pub start_time: Option<String>,
9700    #[serde(default)]
9701    pub end_time: Option<String>,
9702    #[serde(default)]
9703    pub description: Option<String>,
9704}
9705
9706impl From<&crate::types::InstanceStatusReport> for InstanceStatusReportView {
9707    fn from(t: &crate::types::InstanceStatusReport) -> Self {
9708        Self {
9709            instance_id: t.instance_id.clone(),
9710            status: t.status.clone(),
9711            reason_codes: t.reason_codes.clone(),
9712            start_time: t.start_time.clone(),
9713            end_time: t.end_time.clone(),
9714            description: t.description.clone(),
9715        }
9716    }
9717}
9718
9719impl From<InstanceStatusReportView> for crate::types::InstanceStatusReport {
9720    fn from(v: InstanceStatusReportView) -> Self {
9721        Self {
9722            instance_id: v.instance_id,
9723            status: v.status,
9724            reason_codes: v.reason_codes,
9725            start_time: v.start_time,
9726            end_time: v.end_time,
9727            description: v.description,
9728        }
9729    }
9730}
9731
9732impl From<&crate::types::InstanceMetadataDefaults> for InstanceMetadataDefaultsView {
9733    fn from(t: &crate::types::InstanceMetadataDefaults) -> Self {
9734        Self {
9735            http_tokens: t.http_tokens.clone(),
9736            http_put_response_hop_limit: t.http_put_response_hop_limit,
9737            http_endpoint: t.http_endpoint.clone(),
9738            instance_metadata_tags: t.instance_metadata_tags.clone(),
9739        }
9740    }
9741}
9742
9743impl From<InstanceMetadataDefaultsView> for crate::types::InstanceMetadataDefaults {
9744    fn from(v: InstanceMetadataDefaultsView) -> Self {
9745        Self {
9746            http_tokens: v.http_tokens,
9747            http_put_response_hop_limit: v.http_put_response_hop_limit,
9748            http_endpoint: v.http_endpoint,
9749            instance_metadata_tags: v.instance_metadata_tags,
9750        }
9751    }
9752}
9753
9754// ---------------------------------------------------------------------------
9755// Group 6: Network Insights & Traffic Mirror From impls
9756// ---------------------------------------------------------------------------
9757
9758impl From<&PacketHeaderStatementSpec> for PacketHeaderStatementSpecView {
9759    fn from(s: &PacketHeaderStatementSpec) -> Self {
9760        Self {
9761            destination_addresses: s.destination_addresses.clone(),
9762            destination_ports: s.destination_ports.clone(),
9763            destination_prefix_lists: s.destination_prefix_lists.clone(),
9764            protocols: s.protocols.clone(),
9765            source_addresses: s.source_addresses.clone(),
9766            source_ports: s.source_ports.clone(),
9767            source_prefix_lists: s.source_prefix_lists.clone(),
9768        }
9769    }
9770}
9771
9772impl From<PacketHeaderStatementSpecView> for PacketHeaderStatementSpec {
9773    fn from(v: PacketHeaderStatementSpecView) -> Self {
9774        Self {
9775            destination_addresses: v.destination_addresses,
9776            destination_ports: v.destination_ports,
9777            destination_prefix_lists: v.destination_prefix_lists,
9778            protocols: v.protocols,
9779            source_addresses: v.source_addresses,
9780            source_ports: v.source_ports,
9781            source_prefix_lists: v.source_prefix_lists,
9782        }
9783    }
9784}
9785
9786impl From<&ResourceStatementSpec> for ResourceStatementSpecView {
9787    fn from(s: &ResourceStatementSpec) -> Self {
9788        Self {
9789            resource_types: s.resource_types.clone(),
9790            resources: s.resources.clone(),
9791        }
9792    }
9793}
9794
9795impl From<ResourceStatementSpecView> for ResourceStatementSpec {
9796    fn from(v: ResourceStatementSpecView) -> Self {
9797        Self {
9798            resource_types: v.resource_types,
9799            resources: v.resources,
9800        }
9801    }
9802}
9803
9804impl From<&PathStatementSpec> for PathStatementSpecView {
9805    fn from(s: &PathStatementSpec) -> Self {
9806        Self {
9807            packet_header_statement: s
9808                .packet_header_statement
9809                .as_ref()
9810                .map(PacketHeaderStatementSpecView::from),
9811            resource_statement: s
9812                .resource_statement
9813                .as_ref()
9814                .map(ResourceStatementSpecView::from),
9815        }
9816    }
9817}
9818
9819impl From<PathStatementSpecView> for PathStatementSpec {
9820    fn from(v: PathStatementSpecView) -> Self {
9821        Self {
9822            packet_header_statement: v
9823                .packet_header_statement
9824                .map(PacketHeaderStatementSpec::from),
9825            resource_statement: v.resource_statement.map(ResourceStatementSpec::from),
9826        }
9827    }
9828}
9829
9830impl From<&AccessScopePathSpec> for AccessScopePathSpecView {
9831    fn from(s: &AccessScopePathSpec) -> Self {
9832        Self {
9833            source: s.source.as_ref().map(PathStatementSpecView::from),
9834            destination: s.destination.as_ref().map(PathStatementSpecView::from),
9835            through_resources: s
9836                .through_resources
9837                .iter()
9838                .map(ResourceStatementSpecView::from)
9839                .collect(),
9840        }
9841    }
9842}
9843
9844impl From<AccessScopePathSpecView> for AccessScopePathSpec {
9845    fn from(v: AccessScopePathSpecView) -> Self {
9846        Self {
9847            source: v.source.map(PathStatementSpec::from),
9848            destination: v.destination.map(PathStatementSpec::from),
9849            through_resources: v
9850                .through_resources
9851                .into_iter()
9852                .map(ResourceStatementSpec::from)
9853                .collect(),
9854        }
9855    }
9856}
9857
9858impl From<&NetworkInsightsAccessScope> for NetworkInsightsAccessScopeView {
9859    fn from(s: &NetworkInsightsAccessScope) -> Self {
9860        Self {
9861            network_insights_access_scope_id: s.network_insights_access_scope_id.clone(),
9862            network_insights_access_scope_arn: s.network_insights_access_scope_arn.clone(),
9863            created_date: s.created_date.clone(),
9864            updated_date: s.updated_date.clone(),
9865            tags: s.tags.clone(),
9866            match_paths: s
9867                .match_paths
9868                .iter()
9869                .map(AccessScopePathSpecView::from)
9870                .collect(),
9871            exclude_paths: s
9872                .exclude_paths
9873                .iter()
9874                .map(AccessScopePathSpecView::from)
9875                .collect(),
9876        }
9877    }
9878}
9879
9880impl From<NetworkInsightsAccessScopeView> for NetworkInsightsAccessScope {
9881    fn from(v: NetworkInsightsAccessScopeView) -> Self {
9882        Self {
9883            network_insights_access_scope_id: v.network_insights_access_scope_id,
9884            network_insights_access_scope_arn: v.network_insights_access_scope_arn,
9885            created_date: v.created_date,
9886            updated_date: v.updated_date,
9887            tags: v.tags,
9888            match_paths: v
9889                .match_paths
9890                .into_iter()
9891                .map(AccessScopePathSpec::from)
9892                .collect(),
9893            exclude_paths: v
9894                .exclude_paths
9895                .into_iter()
9896                .map(AccessScopePathSpec::from)
9897                .collect(),
9898        }
9899    }
9900}
9901
9902impl From<&NetworkInsightsAccessScopeAnalysis> for NetworkInsightsAccessScopeAnalysisView {
9903    fn from(s: &NetworkInsightsAccessScopeAnalysis) -> Self {
9904        Self {
9905            network_insights_access_scope_analysis_id: s
9906                .network_insights_access_scope_analysis_id
9907                .clone(),
9908            network_insights_access_scope_analysis_arn: s
9909                .network_insights_access_scope_analysis_arn
9910                .clone(),
9911            network_insights_access_scope_id: s.network_insights_access_scope_id.clone(),
9912            status: s.status.clone(),
9913            status_message: s.status_message.clone(),
9914            warning_message: s.warning_message.clone(),
9915            start_date: s.start_date.clone(),
9916            end_date: s.end_date.clone(),
9917            findings_found: s.findings_found.clone(),
9918            analyzed_eni_count: s.analyzed_eni_count,
9919            tags: s.tags.clone(),
9920        }
9921    }
9922}
9923
9924impl From<NetworkInsightsAccessScopeAnalysisView> for NetworkInsightsAccessScopeAnalysis {
9925    fn from(v: NetworkInsightsAccessScopeAnalysisView) -> Self {
9926        Self {
9927            network_insights_access_scope_analysis_id: v.network_insights_access_scope_analysis_id,
9928            network_insights_access_scope_analysis_arn: v
9929                .network_insights_access_scope_analysis_arn,
9930            network_insights_access_scope_id: v.network_insights_access_scope_id,
9931            status: v.status,
9932            status_message: v.status_message,
9933            warning_message: v.warning_message,
9934            start_date: v.start_date,
9935            end_date: v.end_date,
9936            findings_found: v.findings_found,
9937            analyzed_eni_count: v.analyzed_eni_count,
9938            tags: v.tags,
9939        }
9940    }
9941}
9942
9943impl From<&NetworkInsightsPathFilterPortRange> for NetworkInsightsPathFilterPortRangeView {
9944    fn from(p: &NetworkInsightsPathFilterPortRange) -> Self {
9945        Self {
9946            from_port: p.from_port,
9947            to_port: p.to_port,
9948        }
9949    }
9950}
9951
9952impl From<NetworkInsightsPathFilterPortRangeView> for NetworkInsightsPathFilterPortRange {
9953    fn from(v: NetworkInsightsPathFilterPortRangeView) -> Self {
9954        Self {
9955            from_port: v.from_port,
9956            to_port: v.to_port,
9957        }
9958    }
9959}
9960
9961impl From<&NetworkInsightsPathFilter> for NetworkInsightsPathFilterView {
9962    fn from(p: &NetworkInsightsPathFilter) -> Self {
9963        Self {
9964            destination_address: p.destination_address.clone(),
9965            destination_port_range: p
9966                .destination_port_range
9967                .as_ref()
9968                .map(NetworkInsightsPathFilterPortRangeView::from),
9969            source_address: p.source_address.clone(),
9970            source_port_range: p
9971                .source_port_range
9972                .as_ref()
9973                .map(NetworkInsightsPathFilterPortRangeView::from),
9974        }
9975    }
9976}
9977
9978impl From<NetworkInsightsPathFilterView> for NetworkInsightsPathFilter {
9979    fn from(v: NetworkInsightsPathFilterView) -> Self {
9980        Self {
9981            destination_address: v.destination_address,
9982            destination_port_range: v
9983                .destination_port_range
9984                .map(NetworkInsightsPathFilterPortRange::from),
9985            source_address: v.source_address,
9986            source_port_range: v
9987                .source_port_range
9988                .map(NetworkInsightsPathFilterPortRange::from),
9989        }
9990    }
9991}
9992
9993impl From<&NetworkInsightsPath> for NetworkInsightsPathView {
9994    fn from(s: &NetworkInsightsPath) -> Self {
9995        Self {
9996            network_insights_path_id: s.network_insights_path_id.clone(),
9997            network_insights_path_arn: s.network_insights_path_arn.clone(),
9998            created_date: s.created_date.clone(),
9999            source: s.source.clone(),
10000            destination: s.destination.clone(),
10001            source_arn: s.source_arn.clone(),
10002            destination_arn: s.destination_arn.clone(),
10003            source_ip: s.source_ip.clone(),
10004            destination_ip: s.destination_ip.clone(),
10005            protocol: s.protocol.clone(),
10006            destination_port: s.destination_port,
10007            tags: s.tags.clone(),
10008            filter_at_source: NetworkInsightsPathFilterView::from(&s.filter_at_source),
10009            filter_at_destination: NetworkInsightsPathFilterView::from(&s.filter_at_destination),
10010        }
10011    }
10012}
10013
10014impl From<NetworkInsightsPathView> for NetworkInsightsPath {
10015    fn from(v: NetworkInsightsPathView) -> Self {
10016        Self {
10017            network_insights_path_id: v.network_insights_path_id,
10018            network_insights_path_arn: v.network_insights_path_arn,
10019            created_date: v.created_date,
10020            source: v.source,
10021            destination: v.destination,
10022            source_arn: v.source_arn,
10023            destination_arn: v.destination_arn,
10024            source_ip: v.source_ip,
10025            destination_ip: v.destination_ip,
10026            protocol: v.protocol,
10027            destination_port: v.destination_port,
10028            tags: v.tags,
10029            filter_at_source: NetworkInsightsPathFilter::from(v.filter_at_source),
10030            filter_at_destination: NetworkInsightsPathFilter::from(v.filter_at_destination),
10031        }
10032    }
10033}
10034
10035impl From<&NetworkInsightsAnalysis> for NetworkInsightsAnalysisView {
10036    fn from(s: &NetworkInsightsAnalysis) -> Self {
10037        Self {
10038            network_insights_analysis_id: s.network_insights_analysis_id.clone(),
10039            network_insights_analysis_arn: s.network_insights_analysis_arn.clone(),
10040            network_insights_path_id: s.network_insights_path_id.clone(),
10041            additional_accounts: s.additional_accounts.clone(),
10042            filter_in_arns: s.filter_in_arns.clone(),
10043            start_date: s.start_date.clone(),
10044            end_date: s.end_date.clone(),
10045            status: s.status.clone(),
10046            status_message: s.status_message.clone(),
10047            warning_message: s.warning_message.clone(),
10048            network_path_found: s.network_path_found,
10049            tags: s.tags.clone(),
10050        }
10051    }
10052}
10053
10054impl From<NetworkInsightsAnalysisView> for NetworkInsightsAnalysis {
10055    fn from(v: NetworkInsightsAnalysisView) -> Self {
10056        Self {
10057            network_insights_analysis_id: v.network_insights_analysis_id,
10058            network_insights_analysis_arn: v.network_insights_analysis_arn,
10059            network_insights_path_id: v.network_insights_path_id,
10060            additional_accounts: v.additional_accounts,
10061            filter_in_arns: v.filter_in_arns,
10062            start_date: v.start_date,
10063            end_date: v.end_date,
10064            status: v.status,
10065            status_message: v.status_message,
10066            warning_message: v.warning_message,
10067            network_path_found: v.network_path_found,
10068            tags: v.tags,
10069        }
10070    }
10071}
10072
10073impl From<&TrafficMirrorPortRange> for TrafficMirrorPortRangeView {
10074    fn from(p: &TrafficMirrorPortRange) -> Self {
10075        Self {
10076            from_port: p.from_port,
10077            to_port: p.to_port,
10078        }
10079    }
10080}
10081
10082impl From<TrafficMirrorPortRangeView> for TrafficMirrorPortRange {
10083    fn from(v: TrafficMirrorPortRangeView) -> Self {
10084        Self {
10085            from_port: v.from_port,
10086            to_port: v.to_port,
10087        }
10088    }
10089}
10090
10091impl From<&TrafficMirrorFilterRule> for TrafficMirrorFilterRuleView {
10092    fn from(r: &TrafficMirrorFilterRule) -> Self {
10093        Self {
10094            traffic_mirror_filter_rule_id: r.traffic_mirror_filter_rule_id.clone(),
10095            traffic_mirror_filter_id: r.traffic_mirror_filter_id.clone(),
10096            traffic_direction: r.traffic_direction.clone(),
10097            rule_number: r.rule_number,
10098            rule_action: r.rule_action.clone(),
10099            protocol: r.protocol,
10100            destination_port_range: r
10101                .destination_port_range
10102                .as_ref()
10103                .map(TrafficMirrorPortRangeView::from),
10104            source_port_range: r
10105                .source_port_range
10106                .as_ref()
10107                .map(TrafficMirrorPortRangeView::from),
10108            destination_cidr_block: r.destination_cidr_block.clone(),
10109            source_cidr_block: r.source_cidr_block.clone(),
10110            description: r.description.clone(),
10111            tags: r.tags.clone(),
10112        }
10113    }
10114}
10115
10116impl From<TrafficMirrorFilterRuleView> for TrafficMirrorFilterRule {
10117    fn from(v: TrafficMirrorFilterRuleView) -> Self {
10118        Self {
10119            traffic_mirror_filter_rule_id: v.traffic_mirror_filter_rule_id,
10120            traffic_mirror_filter_id: v.traffic_mirror_filter_id,
10121            traffic_direction: v.traffic_direction,
10122            rule_number: v.rule_number,
10123            rule_action: v.rule_action,
10124            protocol: v.protocol,
10125            destination_port_range: v.destination_port_range.map(TrafficMirrorPortRange::from),
10126            source_port_range: v.source_port_range.map(TrafficMirrorPortRange::from),
10127            destination_cidr_block: v.destination_cidr_block,
10128            source_cidr_block: v.source_cidr_block,
10129            description: v.description,
10130            tags: v.tags,
10131        }
10132    }
10133}
10134
10135impl From<&TrafficMirrorFilter> for TrafficMirrorFilterView {
10136    fn from(f: &TrafficMirrorFilter) -> Self {
10137        Self {
10138            traffic_mirror_filter_id: f.traffic_mirror_filter_id.clone(),
10139            description: f.description.clone(),
10140            ingress_filter_rules: f
10141                .ingress_filter_rules
10142                .iter()
10143                .map(TrafficMirrorFilterRuleView::from)
10144                .collect(),
10145            egress_filter_rules: f
10146                .egress_filter_rules
10147                .iter()
10148                .map(TrafficMirrorFilterRuleView::from)
10149                .collect(),
10150            network_services: f.network_services.clone(),
10151            tags: f.tags.clone(),
10152        }
10153    }
10154}
10155
10156impl From<TrafficMirrorFilterView> for TrafficMirrorFilter {
10157    fn from(v: TrafficMirrorFilterView) -> Self {
10158        Self {
10159            traffic_mirror_filter_id: v.traffic_mirror_filter_id,
10160            description: v.description,
10161            ingress_filter_rules: v
10162                .ingress_filter_rules
10163                .into_iter()
10164                .map(TrafficMirrorFilterRule::from)
10165                .collect(),
10166            egress_filter_rules: v
10167                .egress_filter_rules
10168                .into_iter()
10169                .map(TrafficMirrorFilterRule::from)
10170                .collect(),
10171            network_services: v.network_services,
10172            tags: v.tags,
10173        }
10174    }
10175}
10176
10177impl From<&TrafficMirrorSession> for TrafficMirrorSessionView {
10178    fn from(s: &TrafficMirrorSession) -> Self {
10179        Self {
10180            traffic_mirror_session_id: s.traffic_mirror_session_id.clone(),
10181            traffic_mirror_target_id: s.traffic_mirror_target_id.clone(),
10182            traffic_mirror_filter_id: s.traffic_mirror_filter_id.clone(),
10183            network_interface_id: s.network_interface_id.clone(),
10184            owner_id: s.owner_id.clone(),
10185            packet_length: s.packet_length,
10186            session_number: s.session_number,
10187            virtual_network_id: s.virtual_network_id,
10188            description: s.description.clone(),
10189            tags: s.tags.clone(),
10190        }
10191    }
10192}
10193
10194impl From<TrafficMirrorSessionView> for TrafficMirrorSession {
10195    fn from(v: TrafficMirrorSessionView) -> Self {
10196        Self {
10197            traffic_mirror_session_id: v.traffic_mirror_session_id,
10198            traffic_mirror_target_id: v.traffic_mirror_target_id,
10199            traffic_mirror_filter_id: v.traffic_mirror_filter_id,
10200            network_interface_id: v.network_interface_id,
10201            owner_id: v.owner_id,
10202            packet_length: v.packet_length,
10203            session_number: v.session_number,
10204            virtual_network_id: v.virtual_network_id,
10205            description: v.description,
10206            tags: v.tags,
10207        }
10208    }
10209}
10210
10211impl From<&TrafficMirrorTarget> for TrafficMirrorTargetView {
10212    fn from(t: &TrafficMirrorTarget) -> Self {
10213        Self {
10214            traffic_mirror_target_id: t.traffic_mirror_target_id.clone(),
10215            network_interface_id: t.network_interface_id.clone(),
10216            network_load_balancer_arn: t.network_load_balancer_arn.clone(),
10217            gateway_load_balancer_endpoint_id: t.gateway_load_balancer_endpoint_id.clone(),
10218            r#type: t.r#type.clone(),
10219            description: t.description.clone(),
10220            owner_id: t.owner_id.clone(),
10221            tags: t.tags.clone(),
10222        }
10223    }
10224}
10225
10226impl From<TrafficMirrorTargetView> for TrafficMirrorTarget {
10227    fn from(v: TrafficMirrorTargetView) -> Self {
10228        Self {
10229            traffic_mirror_target_id: v.traffic_mirror_target_id,
10230            network_interface_id: v.network_interface_id,
10231            network_load_balancer_arn: v.network_load_balancer_arn,
10232            gateway_load_balancer_endpoint_id: v.gateway_load_balancer_endpoint_id,
10233            r#type: v.r#type,
10234            description: v.description,
10235            owner_id: v.owner_id,
10236            tags: v.tags,
10237        }
10238    }
10239}
10240
10241// ===== Group 7 conversions =====
10242
10243impl From<&ClientVpnEndpoint> for ClientVpnEndpointView {
10244    fn from(e: &ClientVpnEndpoint) -> Self {
10245        ClientVpnEndpointView {
10246            client_vpn_endpoint_id: e.client_vpn_endpoint_id.clone(),
10247            description: e.description.clone(),
10248            status: ClientVpnEndpointStatusView {
10249                code: e.status.code.clone(),
10250                message: e.status.message.clone(),
10251            },
10252            creation_time: e.creation_time.clone(),
10253            deletion_time: e.deletion_time.clone(),
10254            dns_name: e.dns_name.clone(),
10255            client_cidr_block: e.client_cidr_block.clone(),
10256            dns_servers: e.dns_servers.clone(),
10257            split_tunnel: e.split_tunnel,
10258            vpn_protocol: e.vpn_protocol.clone(),
10259            transport_protocol: e.transport_protocol.clone(),
10260            vpn_port: e.vpn_port,
10261            server_certificate_arn: e.server_certificate_arn.clone(),
10262            authentication_options: e.authentication_options.clone(),
10263            connection_log_options_enabled: e.connection_log_options_enabled,
10264            connection_log_options_cloudwatch_log_group: e
10265                .connection_log_options_cloudwatch_log_group
10266                .clone(),
10267            connection_log_options_cloudwatch_log_stream: e
10268                .connection_log_options_cloudwatch_log_stream
10269                .clone(),
10270            tags: e.tags.clone(),
10271            security_group_ids: e.security_group_ids.clone(),
10272            vpc_id: e.vpc_id.clone(),
10273            self_service_portal_url: e.self_service_portal_url.clone(),
10274            self_service_portal: e.self_service_portal.clone(),
10275            session_timeout_hours: e.session_timeout_hours,
10276            client_login_banner_enabled: e.client_login_banner_enabled,
10277            client_login_banner_text: e.client_login_banner_text.clone(),
10278            disconnect_on_session_timeout: e.disconnect_on_session_timeout,
10279            client_route_enforcement_enforced: e.client_route_enforcement_enforced,
10280            client_certificate_revocation_list: e.client_certificate_revocation_list.clone(),
10281        }
10282    }
10283}
10284
10285impl From<ClientVpnEndpointView> for ClientVpnEndpoint {
10286    fn from(v: ClientVpnEndpointView) -> Self {
10287        ClientVpnEndpoint {
10288            client_vpn_endpoint_id: v.client_vpn_endpoint_id,
10289            description: v.description,
10290            status: ClientVpnEndpointStatus {
10291                code: v.status.code,
10292                message: v.status.message,
10293            },
10294            creation_time: v.creation_time,
10295            deletion_time: v.deletion_time,
10296            dns_name: v.dns_name,
10297            client_cidr_block: v.client_cidr_block,
10298            dns_servers: v.dns_servers,
10299            split_tunnel: v.split_tunnel,
10300            vpn_protocol: v.vpn_protocol,
10301            transport_protocol: v.transport_protocol,
10302            vpn_port: v.vpn_port,
10303            server_certificate_arn: v.server_certificate_arn,
10304            authentication_options: v.authentication_options,
10305            connection_log_options_enabled: v.connection_log_options_enabled,
10306            connection_log_options_cloudwatch_log_group: v
10307                .connection_log_options_cloudwatch_log_group,
10308            connection_log_options_cloudwatch_log_stream: v
10309                .connection_log_options_cloudwatch_log_stream,
10310            tags: v.tags,
10311            security_group_ids: v.security_group_ids,
10312            vpc_id: v.vpc_id,
10313            self_service_portal_url: v.self_service_portal_url,
10314            self_service_portal: v.self_service_portal,
10315            session_timeout_hours: v.session_timeout_hours,
10316            client_login_banner_enabled: v.client_login_banner_enabled,
10317            client_login_banner_text: v.client_login_banner_text,
10318            disconnect_on_session_timeout: v.disconnect_on_session_timeout,
10319            client_route_enforcement_enforced: v.client_route_enforcement_enforced,
10320            client_certificate_revocation_list: v.client_certificate_revocation_list,
10321        }
10322    }
10323}
10324
10325impl From<&ClientVpnTargetNetworkAssociation> for ClientVpnTargetNetworkAssociationView {
10326    fn from(a: &ClientVpnTargetNetworkAssociation) -> Self {
10327        ClientVpnTargetNetworkAssociationView {
10328            association_id: a.association_id.clone(),
10329            vpc_id: a.vpc_id.clone(),
10330            target_network_id: a.target_network_id.clone(),
10331            client_vpn_endpoint_id: a.client_vpn_endpoint_id.clone(),
10332            security_groups: a.security_groups.clone(),
10333            status: ClientVpnAssociationStatusView {
10334                code: a.status.code.clone(),
10335                message: a.status.message.clone(),
10336            },
10337        }
10338    }
10339}
10340
10341impl From<ClientVpnTargetNetworkAssociationView> for ClientVpnTargetNetworkAssociation {
10342    fn from(v: ClientVpnTargetNetworkAssociationView) -> Self {
10343        ClientVpnTargetNetworkAssociation {
10344            association_id: v.association_id,
10345            vpc_id: v.vpc_id,
10346            target_network_id: v.target_network_id,
10347            client_vpn_endpoint_id: v.client_vpn_endpoint_id,
10348            security_groups: v.security_groups,
10349            status: ClientVpnAssociationStatus {
10350                code: v.status.code,
10351                message: v.status.message,
10352            },
10353        }
10354    }
10355}
10356
10357impl From<&ClientVpnAuthorizationRule> for ClientVpnAuthorizationRuleView {
10358    fn from(r: &ClientVpnAuthorizationRule) -> Self {
10359        ClientVpnAuthorizationRuleView {
10360            client_vpn_endpoint_id: r.client_vpn_endpoint_id.clone(),
10361            group_id: r.group_id.clone(),
10362            access_all: r.access_all,
10363            destination_cidr: r.destination_cidr.clone(),
10364            description: r.description.clone(),
10365            status: ClientVpnAuthorizationRuleStatusView {
10366                code: r.status.code.clone(),
10367                message: r.status.message.clone(),
10368            },
10369        }
10370    }
10371}
10372
10373impl From<ClientVpnAuthorizationRuleView> for ClientVpnAuthorizationRule {
10374    fn from(v: ClientVpnAuthorizationRuleView) -> Self {
10375        ClientVpnAuthorizationRule {
10376            client_vpn_endpoint_id: v.client_vpn_endpoint_id,
10377            group_id: v.group_id,
10378            access_all: v.access_all,
10379            destination_cidr: v.destination_cidr,
10380            description: v.description,
10381            status: ClientVpnAuthorizationRuleStatus {
10382                code: v.status.code,
10383                message: v.status.message,
10384            },
10385        }
10386    }
10387}
10388
10389impl From<&ClientVpnRoute> for ClientVpnRouteView {
10390    fn from(r: &ClientVpnRoute) -> Self {
10391        ClientVpnRouteView {
10392            client_vpn_endpoint_id: r.client_vpn_endpoint_id.clone(),
10393            destination_cidr: r.destination_cidr.clone(),
10394            target_subnet: r.target_subnet.clone(),
10395            r#type: r.r#type.clone(),
10396            origin: r.origin.clone(),
10397            status: ClientVpnRouteStatusView {
10398                code: r.status.code.clone(),
10399                message: r.status.message.clone(),
10400            },
10401            description: r.description.clone(),
10402        }
10403    }
10404}
10405
10406impl From<ClientVpnRouteView> for ClientVpnRoute {
10407    fn from(v: ClientVpnRouteView) -> Self {
10408        ClientVpnRoute {
10409            client_vpn_endpoint_id: v.client_vpn_endpoint_id,
10410            destination_cidr: v.destination_cidr,
10411            target_subnet: v.target_subnet,
10412            r#type: v.r#type,
10413            origin: v.origin,
10414            status: ClientVpnRouteStatus {
10415                code: v.status.code,
10416                message: v.status.message,
10417            },
10418            description: v.description,
10419        }
10420    }
10421}
10422
10423impl From<&ClientVpnConnection> for ClientVpnConnectionView {
10424    fn from(c: &ClientVpnConnection) -> Self {
10425        ClientVpnConnectionView {
10426            connection_id: c.connection_id.clone(),
10427            client_vpn_endpoint_id: c.client_vpn_endpoint_id.clone(),
10428            username: c.username.clone(),
10429            status: ClientVpnConnectionStatusView {
10430                code: c.status.code.clone(),
10431                message: c.status.message.clone(),
10432            },
10433            posture_compliance_statuses: c.posture_compliance_statuses.clone(),
10434            common_name: c.common_name.clone(),
10435            connection_established_time: c.connection_established_time.clone(),
10436            connection_end_time: c.connection_end_time.clone(),
10437            ingress_bytes: c.ingress_bytes.clone(),
10438            egress_bytes: c.egress_bytes.clone(),
10439            ingress_packets: c.ingress_packets.clone(),
10440            egress_packets: c.egress_packets.clone(),
10441            client_ip: c.client_ip.clone(),
10442            client_port: c.client_port.clone(),
10443            timestamp: c.timestamp.clone(),
10444        }
10445    }
10446}
10447
10448impl From<ClientVpnConnectionView> for ClientVpnConnection {
10449    fn from(v: ClientVpnConnectionView) -> Self {
10450        ClientVpnConnection {
10451            connection_id: v.connection_id,
10452            client_vpn_endpoint_id: v.client_vpn_endpoint_id,
10453            username: v.username,
10454            status: ClientVpnConnectionStatus {
10455                code: v.status.code,
10456                message: v.status.message,
10457            },
10458            posture_compliance_statuses: v.posture_compliance_statuses,
10459            common_name: v.common_name,
10460            connection_established_time: v.connection_established_time,
10461            connection_end_time: v.connection_end_time,
10462            ingress_bytes: v.ingress_bytes,
10463            egress_bytes: v.egress_bytes,
10464            ingress_packets: v.ingress_packets,
10465            egress_packets: v.egress_packets,
10466            client_ip: v.client_ip,
10467            client_port: v.client_port,
10468            timestamp: v.timestamp,
10469        }
10470    }
10471}
10472
10473impl From<&LocalGateway> for LocalGatewayView {
10474    fn from(g: &LocalGateway) -> Self {
10475        LocalGatewayView {
10476            local_gateway_id: g.local_gateway_id.clone(),
10477            outpost_arn: g.outpost_arn.clone(),
10478            owner_id: g.owner_id.clone(),
10479            state: g.state.clone(),
10480            tags: g.tags.clone(),
10481        }
10482    }
10483}
10484
10485impl From<LocalGatewayView> for LocalGateway {
10486    fn from(v: LocalGatewayView) -> Self {
10487        LocalGateway {
10488            local_gateway_id: v.local_gateway_id,
10489            outpost_arn: v.outpost_arn,
10490            owner_id: v.owner_id,
10491            state: v.state,
10492            tags: v.tags,
10493        }
10494    }
10495}
10496
10497impl From<&LocalGatewayRoute> for LocalGatewayRouteView {
10498    fn from(r: &LocalGatewayRoute) -> Self {
10499        LocalGatewayRouteView {
10500            destination_cidr_block: r.destination_cidr_block.clone(),
10501            local_gateway_route_table_id: r.local_gateway_route_table_id.clone(),
10502            r#type: r.r#type.clone(),
10503            state: r.state.clone(),
10504            local_gateway_route_table_arn: r.local_gateway_route_table_arn.clone(),
10505            owner_id: r.owner_id.clone(),
10506            subnet_id: r.subnet_id.clone(),
10507            network_interface_id: r.network_interface_id.clone(),
10508            destination_prefix_list_id: r.destination_prefix_list_id.clone(),
10509            coip_pool_id: r.coip_pool_id.clone(),
10510            local_gateway_virtual_interface_group_id: r
10511                .local_gateway_virtual_interface_group_id
10512                .clone(),
10513        }
10514    }
10515}
10516
10517impl From<LocalGatewayRouteView> for LocalGatewayRoute {
10518    fn from(v: LocalGatewayRouteView) -> Self {
10519        LocalGatewayRoute {
10520            destination_cidr_block: v.destination_cidr_block,
10521            local_gateway_route_table_id: v.local_gateway_route_table_id,
10522            r#type: v.r#type,
10523            state: v.state,
10524            local_gateway_route_table_arn: v.local_gateway_route_table_arn,
10525            owner_id: v.owner_id,
10526            subnet_id: v.subnet_id,
10527            network_interface_id: v.network_interface_id,
10528            destination_prefix_list_id: v.destination_prefix_list_id,
10529            coip_pool_id: v.coip_pool_id,
10530            local_gateway_virtual_interface_group_id: v.local_gateway_virtual_interface_group_id,
10531        }
10532    }
10533}
10534
10535impl From<&LocalGatewayRouteTable> for LocalGatewayRouteTableView {
10536    fn from(t: &LocalGatewayRouteTable) -> Self {
10537        LocalGatewayRouteTableView {
10538            local_gateway_route_table_id: t.local_gateway_route_table_id.clone(),
10539            local_gateway_route_table_arn: t.local_gateway_route_table_arn.clone(),
10540            local_gateway_id: t.local_gateway_id.clone(),
10541            owner_id: t.owner_id.clone(),
10542            state: t.state.clone(),
10543            mode: t.mode.clone(),
10544            tags: t.tags.clone(),
10545            state_reason_code: t.state_reason_code.clone(),
10546            state_reason_message: t.state_reason_message.clone(),
10547        }
10548    }
10549}
10550
10551impl From<LocalGatewayRouteTableView> for LocalGatewayRouteTable {
10552    fn from(v: LocalGatewayRouteTableView) -> Self {
10553        LocalGatewayRouteTable {
10554            local_gateway_route_table_id: v.local_gateway_route_table_id,
10555            local_gateway_route_table_arn: v.local_gateway_route_table_arn,
10556            local_gateway_id: v.local_gateway_id,
10557            owner_id: v.owner_id,
10558            state: v.state,
10559            mode: v.mode,
10560            tags: v.tags,
10561            state_reason_code: v.state_reason_code,
10562            state_reason_message: v.state_reason_message,
10563        }
10564    }
10565}
10566
10567impl From<&LocalGatewayRouteTableVirtualInterfaceGroupAssociation>
10568    for LocalGatewayRouteTableVirtualInterfaceGroupAssociationView
10569{
10570    fn from(a: &LocalGatewayRouteTableVirtualInterfaceGroupAssociation) -> Self {
10571        LocalGatewayRouteTableVirtualInterfaceGroupAssociationView {
10572            local_gateway_route_table_virtual_interface_group_association_id: a
10573                .local_gateway_route_table_virtual_interface_group_association_id
10574                .clone(),
10575            local_gateway_virtual_interface_group_id: a
10576                .local_gateway_virtual_interface_group_id
10577                .clone(),
10578            local_gateway_route_table_id: a.local_gateway_route_table_id.clone(),
10579            local_gateway_route_table_arn: a.local_gateway_route_table_arn.clone(),
10580            local_gateway_id: a.local_gateway_id.clone(),
10581            owner_id: a.owner_id.clone(),
10582            state: a.state.clone(),
10583            tags: a.tags.clone(),
10584        }
10585    }
10586}
10587
10588impl From<LocalGatewayRouteTableVirtualInterfaceGroupAssociationView>
10589    for LocalGatewayRouteTableVirtualInterfaceGroupAssociation
10590{
10591    fn from(v: LocalGatewayRouteTableVirtualInterfaceGroupAssociationView) -> Self {
10592        LocalGatewayRouteTableVirtualInterfaceGroupAssociation {
10593            local_gateway_route_table_virtual_interface_group_association_id: v
10594                .local_gateway_route_table_virtual_interface_group_association_id,
10595            local_gateway_virtual_interface_group_id: v.local_gateway_virtual_interface_group_id,
10596            local_gateway_route_table_id: v.local_gateway_route_table_id,
10597            local_gateway_route_table_arn: v.local_gateway_route_table_arn,
10598            local_gateway_id: v.local_gateway_id,
10599            owner_id: v.owner_id,
10600            state: v.state,
10601            tags: v.tags,
10602        }
10603    }
10604}
10605
10606impl From<&LocalGatewayRouteTableVpcAssociation> for LocalGatewayRouteTableVpcAssociationView {
10607    fn from(a: &LocalGatewayRouteTableVpcAssociation) -> Self {
10608        LocalGatewayRouteTableVpcAssociationView {
10609            local_gateway_route_table_vpc_association_id: a
10610                .local_gateway_route_table_vpc_association_id
10611                .clone(),
10612            local_gateway_route_table_id: a.local_gateway_route_table_id.clone(),
10613            local_gateway_route_table_arn: a.local_gateway_route_table_arn.clone(),
10614            local_gateway_id: a.local_gateway_id.clone(),
10615            vpc_id: a.vpc_id.clone(),
10616            owner_id: a.owner_id.clone(),
10617            state: a.state.clone(),
10618            tags: a.tags.clone(),
10619        }
10620    }
10621}
10622
10623impl From<LocalGatewayRouteTableVpcAssociationView> for LocalGatewayRouteTableVpcAssociation {
10624    fn from(v: LocalGatewayRouteTableVpcAssociationView) -> Self {
10625        LocalGatewayRouteTableVpcAssociation {
10626            local_gateway_route_table_vpc_association_id: v
10627                .local_gateway_route_table_vpc_association_id,
10628            local_gateway_route_table_id: v.local_gateway_route_table_id,
10629            local_gateway_route_table_arn: v.local_gateway_route_table_arn,
10630            local_gateway_id: v.local_gateway_id,
10631            vpc_id: v.vpc_id,
10632            owner_id: v.owner_id,
10633            state: v.state,
10634            tags: v.tags,
10635        }
10636    }
10637}
10638
10639impl From<&LocalGatewayVirtualInterface> for LocalGatewayVirtualInterfaceView {
10640    fn from(i: &LocalGatewayVirtualInterface) -> Self {
10641        LocalGatewayVirtualInterfaceView {
10642            local_gateway_virtual_interface_id: i.local_gateway_virtual_interface_id.clone(),
10643            local_gateway_id: i.local_gateway_id.clone(),
10644            vlan: i.vlan,
10645            local_address: i.local_address.clone(),
10646            peer_address: i.peer_address.clone(),
10647            local_bgp_asn: i.local_bgp_asn,
10648            peer_bgp_asn: i.peer_bgp_asn,
10649            owner_id: i.owner_id.clone(),
10650            tags: i.tags.clone(),
10651            configuration_state: i.configuration_state.clone(),
10652            peer_bgp_asn_extended: i.peer_bgp_asn_extended,
10653            local_gateway_virtual_interface_arn: i.local_gateway_virtual_interface_arn.clone(),
10654        }
10655    }
10656}
10657
10658impl From<LocalGatewayVirtualInterfaceView> for LocalGatewayVirtualInterface {
10659    fn from(v: LocalGatewayVirtualInterfaceView) -> Self {
10660        LocalGatewayVirtualInterface {
10661            local_gateway_virtual_interface_id: v.local_gateway_virtual_interface_id,
10662            local_gateway_id: v.local_gateway_id,
10663            vlan: v.vlan,
10664            local_address: v.local_address,
10665            peer_address: v.peer_address,
10666            local_bgp_asn: v.local_bgp_asn,
10667            peer_bgp_asn: v.peer_bgp_asn,
10668            owner_id: v.owner_id,
10669            tags: v.tags,
10670            configuration_state: v.configuration_state,
10671            peer_bgp_asn_extended: v.peer_bgp_asn_extended,
10672            local_gateway_virtual_interface_arn: v.local_gateway_virtual_interface_arn,
10673        }
10674    }
10675}
10676
10677impl From<&LocalGatewayVirtualInterfaceGroup> for LocalGatewayVirtualInterfaceGroupView {
10678    fn from(g: &LocalGatewayVirtualInterfaceGroup) -> Self {
10679        LocalGatewayVirtualInterfaceGroupView {
10680            local_gateway_virtual_interface_group_id: g
10681                .local_gateway_virtual_interface_group_id
10682                .clone(),
10683            local_gateway_virtual_interface_ids: g.local_gateway_virtual_interface_ids.clone(),
10684            local_gateway_id: g.local_gateway_id.clone(),
10685            owner_id: g.owner_id.clone(),
10686            tags: g.tags.clone(),
10687            configuration_state: g.configuration_state.clone(),
10688            local_bgp_asn: g.local_bgp_asn,
10689            local_bgp_asn_extended: g.local_bgp_asn_extended,
10690            local_gateway_virtual_interface_group_arn: g
10691                .local_gateway_virtual_interface_group_arn
10692                .clone(),
10693        }
10694    }
10695}
10696
10697impl From<LocalGatewayVirtualInterfaceGroupView> for LocalGatewayVirtualInterfaceGroup {
10698    fn from(v: LocalGatewayVirtualInterfaceGroupView) -> Self {
10699        LocalGatewayVirtualInterfaceGroup {
10700            local_gateway_virtual_interface_group_id: v.local_gateway_virtual_interface_group_id,
10701            local_gateway_virtual_interface_ids: v.local_gateway_virtual_interface_ids,
10702            local_gateway_id: v.local_gateway_id,
10703            owner_id: v.owner_id,
10704            tags: v.tags,
10705            configuration_state: v.configuration_state,
10706            local_bgp_asn: v.local_bgp_asn,
10707            local_bgp_asn_extended: v.local_bgp_asn_extended,
10708            local_gateway_virtual_interface_group_arn: v.local_gateway_virtual_interface_group_arn,
10709        }
10710    }
10711}
10712
10713// ===== Group 8: Route Server From impls =====
10714
10715impl From<&RouteServer> for RouteServerView {
10716    fn from(r: &RouteServer) -> Self {
10717        RouteServerView {
10718            route_server_id: r.route_server_id.clone(),
10719            route_server_arn: r.route_server_arn.clone(),
10720            amazon_side_asn: r.amazon_side_asn,
10721            state: r.state.clone(),
10722            persist_routes: r.persist_routes.clone(),
10723            persist_routes_duration: r.persist_routes_duration,
10724            sns_notifications_enabled: r.sns_notifications_enabled,
10725            sns_topic_arn: r.sns_topic_arn.clone(),
10726            tags: r.tags.clone(),
10727        }
10728    }
10729}
10730
10731impl From<RouteServerView> for RouteServer {
10732    fn from(v: RouteServerView) -> Self {
10733        RouteServer {
10734            route_server_id: v.route_server_id,
10735            route_server_arn: v.route_server_arn,
10736            amazon_side_asn: v.amazon_side_asn,
10737            state: v.state,
10738            persist_routes: v.persist_routes,
10739            persist_routes_duration: v.persist_routes_duration,
10740            sns_notifications_enabled: v.sns_notifications_enabled,
10741            sns_topic_arn: v.sns_topic_arn,
10742            tags: v.tags,
10743        }
10744    }
10745}
10746
10747impl From<&RouteServerEndpoint> for RouteServerEndpointView {
10748    fn from(e: &RouteServerEndpoint) -> Self {
10749        RouteServerEndpointView {
10750            route_server_endpoint_id: e.route_server_endpoint_id.clone(),
10751            route_server_id: e.route_server_id.clone(),
10752            vpc_id: e.vpc_id.clone(),
10753            subnet_id: e.subnet_id.clone(),
10754            eni_id: e.eni_id.clone(),
10755            eni_address: e.eni_address.clone(),
10756            state: e.state.clone(),
10757            failure_reason: e.failure_reason.clone(),
10758            tags: e.tags.clone(),
10759        }
10760    }
10761}
10762
10763impl From<RouteServerEndpointView> for RouteServerEndpoint {
10764    fn from(v: RouteServerEndpointView) -> Self {
10765        RouteServerEndpoint {
10766            route_server_endpoint_id: v.route_server_endpoint_id,
10767            route_server_id: v.route_server_id,
10768            vpc_id: v.vpc_id,
10769            subnet_id: v.subnet_id,
10770            eni_id: v.eni_id,
10771            eni_address: v.eni_address,
10772            state: v.state,
10773            failure_reason: v.failure_reason,
10774            tags: v.tags,
10775        }
10776    }
10777}
10778
10779impl From<&RouteServerBgpOptions> for RouteServerBgpOptionsView {
10780    fn from(o: &RouteServerBgpOptions) -> Self {
10781        RouteServerBgpOptionsView {
10782            peer_asn: o.peer_asn,
10783            peer_liveness_detection: o.peer_liveness_detection.clone(),
10784        }
10785    }
10786}
10787
10788impl From<RouteServerBgpOptionsView> for RouteServerBgpOptions {
10789    fn from(v: RouteServerBgpOptionsView) -> Self {
10790        RouteServerBgpOptions {
10791            peer_asn: v.peer_asn,
10792            peer_liveness_detection: v.peer_liveness_detection,
10793        }
10794    }
10795}
10796
10797impl From<&RouteServerPeerOptions> for RouteServerPeerOptionsView {
10798    fn from(o: &RouteServerPeerOptions) -> Self {
10799        RouteServerPeerOptionsView {
10800            peer_asn: o.peer_asn,
10801            peer_liveness_detection: o.peer_liveness_detection.clone(),
10802            bgp_options: o.bgp_options.as_ref().map(RouteServerBgpOptionsView::from),
10803        }
10804    }
10805}
10806
10807impl From<RouteServerPeerOptionsView> for RouteServerPeerOptions {
10808    fn from(v: RouteServerPeerOptionsView) -> Self {
10809        RouteServerPeerOptions {
10810            peer_asn: v.peer_asn,
10811            peer_liveness_detection: v.peer_liveness_detection,
10812            bgp_options: v.bgp_options.map(RouteServerBgpOptions::from),
10813        }
10814    }
10815}
10816
10817impl From<&RouteServerPeer> for RouteServerPeerView {
10818    fn from(p: &RouteServerPeer) -> Self {
10819        RouteServerPeerView {
10820            route_server_peer_id: p.route_server_peer_id.clone(),
10821            route_server_endpoint_id: p.route_server_endpoint_id.clone(),
10822            route_server_id: p.route_server_id.clone(),
10823            vpc_id: p.vpc_id.clone(),
10824            subnet_id: p.subnet_id.clone(),
10825            peer_address: p.peer_address.clone(),
10826            state: p.state.clone(),
10827            failure_reason: p.failure_reason.clone(),
10828            options: RouteServerPeerOptionsView::from(&p.options),
10829            endpoint_eni_id: p.endpoint_eni_id.clone(),
10830            endpoint_eni_address: p.endpoint_eni_address.clone(),
10831            tags: p.tags.clone(),
10832        }
10833    }
10834}
10835
10836impl From<RouteServerPeerView> for RouteServerPeer {
10837    fn from(v: RouteServerPeerView) -> Self {
10838        RouteServerPeer {
10839            route_server_peer_id: v.route_server_peer_id,
10840            route_server_endpoint_id: v.route_server_endpoint_id,
10841            route_server_id: v.route_server_id,
10842            vpc_id: v.vpc_id,
10843            subnet_id: v.subnet_id,
10844            peer_address: v.peer_address,
10845            state: v.state,
10846            failure_reason: v.failure_reason,
10847            options: RouteServerPeerOptions::from(v.options),
10848            endpoint_eni_id: v.endpoint_eni_id,
10849            endpoint_eni_address: v.endpoint_eni_address,
10850            tags: v.tags,
10851        }
10852    }
10853}
10854
10855impl From<&RouteServerAssociation> for RouteServerAssociationView {
10856    fn from(a: &RouteServerAssociation) -> Self {
10857        RouteServerAssociationView {
10858            route_server_id: a.route_server_id.clone(),
10859            vpc_id: a.vpc_id.clone(),
10860            state: a.state.clone(),
10861            propagations: a.propagations.clone(),
10862        }
10863    }
10864}
10865
10866impl From<RouteServerAssociationView> for RouteServerAssociation {
10867    fn from(v: RouteServerAssociationView) -> Self {
10868        RouteServerAssociation {
10869            route_server_id: v.route_server_id,
10870            vpc_id: v.vpc_id,
10871            state: v.state,
10872            propagations: v.propagations,
10873        }
10874    }
10875}
10876
10877// ===== Group 9: Verified Access view conversions =====
10878
10879impl From<&VerifiedAccessInstance> for VerifiedAccessInstanceView {
10880    fn from(i: &VerifiedAccessInstance) -> Self {
10881        VerifiedAccessInstanceView {
10882            verified_access_instance_id: i.verified_access_instance_id.clone(),
10883            description: i.description.clone(),
10884            creation_time: i.creation_time.clone(),
10885            last_updated_time: i.last_updated_time.clone(),
10886            fips_enabled: i.fips_enabled,
10887            cidr_endpoints_custom_subdomain: i.cidr_endpoints_custom_subdomain.clone(),
10888            name: i.name.clone(),
10889            trust_provider_ids: i.trust_provider_ids.clone(),
10890            tags: i.tags.clone(),
10891        }
10892    }
10893}
10894
10895impl From<VerifiedAccessInstanceView> for VerifiedAccessInstance {
10896    fn from(v: VerifiedAccessInstanceView) -> Self {
10897        VerifiedAccessInstance {
10898            verified_access_instance_id: v.verified_access_instance_id,
10899            description: v.description,
10900            creation_time: v.creation_time,
10901            last_updated_time: v.last_updated_time,
10902            fips_enabled: v.fips_enabled,
10903            cidr_endpoints_custom_subdomain: v.cidr_endpoints_custom_subdomain,
10904            name: v.name,
10905            trust_provider_ids: v.trust_provider_ids,
10906            tags: v.tags,
10907        }
10908    }
10909}
10910
10911impl From<&VerifiedAccessOidcOptions> for VerifiedAccessOidcOptionsView {
10912    fn from(o: &VerifiedAccessOidcOptions) -> Self {
10913        VerifiedAccessOidcOptionsView {
10914            issuer: o.issuer.clone(),
10915            authorization_endpoint: o.authorization_endpoint.clone(),
10916            token_endpoint: o.token_endpoint.clone(),
10917            user_info_endpoint: o.user_info_endpoint.clone(),
10918            client_id: o.client_id.clone(),
10919            client_secret: o.client_secret.clone(),
10920            scope: o.scope.clone(),
10921        }
10922    }
10923}
10924
10925impl From<VerifiedAccessOidcOptionsView> for VerifiedAccessOidcOptions {
10926    fn from(v: VerifiedAccessOidcOptionsView) -> Self {
10927        VerifiedAccessOidcOptions {
10928            issuer: v.issuer,
10929            authorization_endpoint: v.authorization_endpoint,
10930            token_endpoint: v.token_endpoint,
10931            user_info_endpoint: v.user_info_endpoint,
10932            client_id: v.client_id,
10933            client_secret: v.client_secret,
10934            scope: v.scope,
10935        }
10936    }
10937}
10938
10939impl From<&VerifiedAccessDeviceOptions> for VerifiedAccessDeviceOptionsView {
10940    fn from(o: &VerifiedAccessDeviceOptions) -> Self {
10941        VerifiedAccessDeviceOptionsView {
10942            tenant_id: o.tenant_id.clone(),
10943            public_signing_key_url: o.public_signing_key_url.clone(),
10944        }
10945    }
10946}
10947
10948impl From<VerifiedAccessDeviceOptionsView> for VerifiedAccessDeviceOptions {
10949    fn from(v: VerifiedAccessDeviceOptionsView) -> Self {
10950        VerifiedAccessDeviceOptions {
10951            tenant_id: v.tenant_id,
10952            public_signing_key_url: v.public_signing_key_url,
10953        }
10954    }
10955}
10956
10957impl From<&VerifiedAccessNativeApplicationOidcOptions>
10958    for VerifiedAccessNativeApplicationOidcOptionsView
10959{
10960    fn from(o: &VerifiedAccessNativeApplicationOidcOptions) -> Self {
10961        VerifiedAccessNativeApplicationOidcOptionsView {
10962            public_signing_key_endpoint: o.public_signing_key_endpoint.clone(),
10963            issuer: o.issuer.clone(),
10964            authorization_endpoint: o.authorization_endpoint.clone(),
10965            token_endpoint: o.token_endpoint.clone(),
10966            user_info_endpoint: o.user_info_endpoint.clone(),
10967            client_id: o.client_id.clone(),
10968            client_secret: o.client_secret.clone(),
10969            scope: o.scope.clone(),
10970        }
10971    }
10972}
10973
10974impl From<VerifiedAccessNativeApplicationOidcOptionsView>
10975    for VerifiedAccessNativeApplicationOidcOptions
10976{
10977    fn from(v: VerifiedAccessNativeApplicationOidcOptionsView) -> Self {
10978        VerifiedAccessNativeApplicationOidcOptions {
10979            public_signing_key_endpoint: v.public_signing_key_endpoint,
10980            issuer: v.issuer,
10981            authorization_endpoint: v.authorization_endpoint,
10982            token_endpoint: v.token_endpoint,
10983            user_info_endpoint: v.user_info_endpoint,
10984            client_id: v.client_id,
10985            client_secret: v.client_secret,
10986            scope: v.scope,
10987        }
10988    }
10989}
10990
10991impl From<&VerifiedAccessSseSpecification> for VerifiedAccessSseSpecificationView {
10992    fn from(s: &VerifiedAccessSseSpecification) -> Self {
10993        VerifiedAccessSseSpecificationView {
10994            customer_managed_key_enabled: s.customer_managed_key_enabled,
10995            kms_key_arn: s.kms_key_arn.clone(),
10996        }
10997    }
10998}
10999
11000impl From<VerifiedAccessSseSpecificationView> for VerifiedAccessSseSpecification {
11001    fn from(v: VerifiedAccessSseSpecificationView) -> Self {
11002        VerifiedAccessSseSpecification {
11003            customer_managed_key_enabled: v.customer_managed_key_enabled,
11004            kms_key_arn: v.kms_key_arn,
11005        }
11006    }
11007}
11008
11009impl From<&VerifiedAccessTrustProvider> for VerifiedAccessTrustProviderView {
11010    fn from(t: &VerifiedAccessTrustProvider) -> Self {
11011        VerifiedAccessTrustProviderView {
11012            verified_access_trust_provider_id: t.verified_access_trust_provider_id.clone(),
11013            description: t.description.clone(),
11014            trust_provider_type: t.trust_provider_type.clone(),
11015            user_trust_provider_type: t.user_trust_provider_type.clone(),
11016            device_trust_provider_type: t.device_trust_provider_type.clone(),
11017            oidc_options: t
11018                .oidc_options
11019                .as_ref()
11020                .map(VerifiedAccessOidcOptionsView::from),
11021            device_options: t
11022                .device_options
11023                .as_ref()
11024                .map(VerifiedAccessDeviceOptionsView::from),
11025            native_application_oidc_options: t
11026                .native_application_oidc_options
11027                .as_ref()
11028                .map(VerifiedAccessNativeApplicationOidcOptionsView::from),
11029            policy_reference_name: t.policy_reference_name.clone(),
11030            creation_time: t.creation_time.clone(),
11031            last_updated_time: t.last_updated_time.clone(),
11032            sse_specification: VerifiedAccessSseSpecificationView::from(&t.sse_specification),
11033            tags: t.tags.clone(),
11034        }
11035    }
11036}
11037
11038impl From<VerifiedAccessTrustProviderView> for VerifiedAccessTrustProvider {
11039    fn from(v: VerifiedAccessTrustProviderView) -> Self {
11040        VerifiedAccessTrustProvider {
11041            verified_access_trust_provider_id: v.verified_access_trust_provider_id,
11042            description: v.description,
11043            trust_provider_type: v.trust_provider_type,
11044            user_trust_provider_type: v.user_trust_provider_type,
11045            device_trust_provider_type: v.device_trust_provider_type,
11046            oidc_options: v.oidc_options.map(VerifiedAccessOidcOptions::from),
11047            device_options: v.device_options.map(VerifiedAccessDeviceOptions::from),
11048            native_application_oidc_options: v
11049                .native_application_oidc_options
11050                .map(VerifiedAccessNativeApplicationOidcOptions::from),
11051            policy_reference_name: v.policy_reference_name,
11052            creation_time: v.creation_time,
11053            last_updated_time: v.last_updated_time,
11054            sse_specification: VerifiedAccessSseSpecification::from(v.sse_specification),
11055            tags: v.tags,
11056        }
11057    }
11058}
11059
11060impl From<&VerifiedAccessGroup> for VerifiedAccessGroupView {
11061    fn from(g: &VerifiedAccessGroup) -> Self {
11062        VerifiedAccessGroupView {
11063            verified_access_group_id: g.verified_access_group_id.clone(),
11064            verified_access_group_arn: g.verified_access_group_arn.clone(),
11065            verified_access_instance_id: g.verified_access_instance_id.clone(),
11066            owner: g.owner.clone(),
11067            description: g.description.clone(),
11068            creation_time: g.creation_time.clone(),
11069            last_updated_time: g.last_updated_time.clone(),
11070            deletion_time: g.deletion_time.clone(),
11071            sse_specification: VerifiedAccessSseSpecificationView::from(&g.sse_specification),
11072            policy_document: g.policy_document.clone(),
11073            policy_enabled: g.policy_enabled,
11074            tags: g.tags.clone(),
11075        }
11076    }
11077}
11078
11079impl From<VerifiedAccessGroupView> for VerifiedAccessGroup {
11080    fn from(v: VerifiedAccessGroupView) -> Self {
11081        VerifiedAccessGroup {
11082            verified_access_group_id: v.verified_access_group_id,
11083            verified_access_group_arn: v.verified_access_group_arn,
11084            verified_access_instance_id: v.verified_access_instance_id,
11085            owner: v.owner,
11086            description: v.description,
11087            creation_time: v.creation_time,
11088            last_updated_time: v.last_updated_time,
11089            deletion_time: v.deletion_time,
11090            sse_specification: VerifiedAccessSseSpecification::from(v.sse_specification),
11091            policy_document: v.policy_document,
11092            policy_enabled: v.policy_enabled,
11093            tags: v.tags,
11094        }
11095    }
11096}
11097
11098impl From<&VerifiedAccessEndpointPortRange> for VerifiedAccessEndpointPortRangeView {
11099    fn from(p: &VerifiedAccessEndpointPortRange) -> Self {
11100        VerifiedAccessEndpointPortRangeView {
11101            from_port: p.from_port,
11102            to_port: p.to_port,
11103        }
11104    }
11105}
11106
11107impl From<VerifiedAccessEndpointPortRangeView> for VerifiedAccessEndpointPortRange {
11108    fn from(v: VerifiedAccessEndpointPortRangeView) -> Self {
11109        VerifiedAccessEndpointPortRange {
11110            from_port: v.from_port,
11111            to_port: v.to_port,
11112        }
11113    }
11114}
11115
11116impl From<&VerifiedAccessEndpointLoadBalancerOptions>
11117    for VerifiedAccessEndpointLoadBalancerOptionsView
11118{
11119    fn from(o: &VerifiedAccessEndpointLoadBalancerOptions) -> Self {
11120        VerifiedAccessEndpointLoadBalancerOptionsView {
11121            load_balancer_arn: o.load_balancer_arn.clone(),
11122            port: o.port,
11123            port_ranges: o
11124                .port_ranges
11125                .iter()
11126                .map(VerifiedAccessEndpointPortRangeView::from)
11127                .collect(),
11128            protocol: o.protocol.clone(),
11129            subnet_ids: o.subnet_ids.clone(),
11130        }
11131    }
11132}
11133
11134impl From<VerifiedAccessEndpointLoadBalancerOptionsView>
11135    for VerifiedAccessEndpointLoadBalancerOptions
11136{
11137    fn from(v: VerifiedAccessEndpointLoadBalancerOptionsView) -> Self {
11138        VerifiedAccessEndpointLoadBalancerOptions {
11139            load_balancer_arn: v.load_balancer_arn,
11140            port: v.port,
11141            port_ranges: v
11142                .port_ranges
11143                .into_iter()
11144                .map(VerifiedAccessEndpointPortRange::from)
11145                .collect(),
11146            protocol: v.protocol,
11147            subnet_ids: v.subnet_ids,
11148        }
11149    }
11150}
11151
11152impl From<&VerifiedAccessEndpointEniOptions> for VerifiedAccessEndpointEniOptionsView {
11153    fn from(o: &VerifiedAccessEndpointEniOptions) -> Self {
11154        VerifiedAccessEndpointEniOptionsView {
11155            network_interface_id: o.network_interface_id.clone(),
11156            port: o.port,
11157            port_ranges: o
11158                .port_ranges
11159                .iter()
11160                .map(VerifiedAccessEndpointPortRangeView::from)
11161                .collect(),
11162            protocol: o.protocol.clone(),
11163        }
11164    }
11165}
11166
11167impl From<VerifiedAccessEndpointEniOptionsView> for VerifiedAccessEndpointEniOptions {
11168    fn from(v: VerifiedAccessEndpointEniOptionsView) -> Self {
11169        VerifiedAccessEndpointEniOptions {
11170            network_interface_id: v.network_interface_id,
11171            port: v.port,
11172            port_ranges: v
11173                .port_ranges
11174                .into_iter()
11175                .map(VerifiedAccessEndpointPortRange::from)
11176                .collect(),
11177            protocol: v.protocol,
11178        }
11179    }
11180}
11181
11182impl From<&VerifiedAccessEndpointCidrOptions> for VerifiedAccessEndpointCidrOptionsView {
11183    fn from(o: &VerifiedAccessEndpointCidrOptions) -> Self {
11184        VerifiedAccessEndpointCidrOptionsView {
11185            cidr: o.cidr.clone(),
11186            port_ranges: o
11187                .port_ranges
11188                .iter()
11189                .map(VerifiedAccessEndpointPortRangeView::from)
11190                .collect(),
11191            protocol: o.protocol.clone(),
11192            subnet_ids: o.subnet_ids.clone(),
11193        }
11194    }
11195}
11196
11197impl From<VerifiedAccessEndpointCidrOptionsView> for VerifiedAccessEndpointCidrOptions {
11198    fn from(v: VerifiedAccessEndpointCidrOptionsView) -> Self {
11199        VerifiedAccessEndpointCidrOptions {
11200            cidr: v.cidr,
11201            port_ranges: v
11202                .port_ranges
11203                .into_iter()
11204                .map(VerifiedAccessEndpointPortRange::from)
11205                .collect(),
11206            protocol: v.protocol,
11207            subnet_ids: v.subnet_ids,
11208        }
11209    }
11210}
11211
11212impl From<&VerifiedAccessEndpointRdsOptions> for VerifiedAccessEndpointRdsOptionsView {
11213    fn from(o: &VerifiedAccessEndpointRdsOptions) -> Self {
11214        VerifiedAccessEndpointRdsOptionsView {
11215            port: o.port,
11216            protocol: o.protocol.clone(),
11217            rds_db_cluster_arn: o.rds_db_cluster_arn.clone(),
11218            rds_db_instance_arn: o.rds_db_instance_arn.clone(),
11219            rds_db_proxy_arn: o.rds_db_proxy_arn.clone(),
11220            rds_endpoint: o.rds_endpoint.clone(),
11221            subnet_ids: o.subnet_ids.clone(),
11222        }
11223    }
11224}
11225
11226impl From<VerifiedAccessEndpointRdsOptionsView> for VerifiedAccessEndpointRdsOptions {
11227    fn from(v: VerifiedAccessEndpointRdsOptionsView) -> Self {
11228        VerifiedAccessEndpointRdsOptions {
11229            port: v.port,
11230            protocol: v.protocol,
11231            rds_db_cluster_arn: v.rds_db_cluster_arn,
11232            rds_db_instance_arn: v.rds_db_instance_arn,
11233            rds_db_proxy_arn: v.rds_db_proxy_arn,
11234            rds_endpoint: v.rds_endpoint,
11235            subnet_ids: v.subnet_ids,
11236        }
11237    }
11238}
11239
11240impl From<&VerifiedAccessEndpoint> for VerifiedAccessEndpointView {
11241    fn from(e: &VerifiedAccessEndpoint) -> Self {
11242        VerifiedAccessEndpointView {
11243            verified_access_endpoint_id: e.verified_access_endpoint_id.clone(),
11244            verified_access_instance_id: e.verified_access_instance_id.clone(),
11245            verified_access_group_id: e.verified_access_group_id.clone(),
11246            application_domain: e.application_domain.clone(),
11247            endpoint_type: e.endpoint_type.clone(),
11248            attachment_type: e.attachment_type.clone(),
11249            domain_certificate_arn: e.domain_certificate_arn.clone(),
11250            endpoint_domain: e.endpoint_domain.clone(),
11251            device_validation_domain: e.device_validation_domain.clone(),
11252            security_group_ids: e.security_group_ids.clone(),
11253            load_balancer_options: e
11254                .load_balancer_options
11255                .as_ref()
11256                .map(VerifiedAccessEndpointLoadBalancerOptionsView::from),
11257            network_interface_options: e
11258                .network_interface_options
11259                .as_ref()
11260                .map(VerifiedAccessEndpointEniOptionsView::from),
11261            cidr_options: e
11262                .cidr_options
11263                .as_ref()
11264                .map(VerifiedAccessEndpointCidrOptionsView::from),
11265            rds_options: e
11266                .rds_options
11267                .as_ref()
11268                .map(VerifiedAccessEndpointRdsOptionsView::from),
11269            status_code: e.status_code.clone(),
11270            status_message: e.status_message.clone(),
11271            description: e.description.clone(),
11272            creation_time: e.creation_time.clone(),
11273            last_updated_time: e.last_updated_time.clone(),
11274            deletion_time: e.deletion_time.clone(),
11275            sse_specification: VerifiedAccessSseSpecificationView::from(&e.sse_specification),
11276            policy_document: e.policy_document.clone(),
11277            policy_enabled: e.policy_enabled,
11278            tags: e.tags.clone(),
11279        }
11280    }
11281}
11282
11283impl From<VerifiedAccessEndpointView> for VerifiedAccessEndpoint {
11284    fn from(v: VerifiedAccessEndpointView) -> Self {
11285        VerifiedAccessEndpoint {
11286            verified_access_endpoint_id: v.verified_access_endpoint_id,
11287            verified_access_instance_id: v.verified_access_instance_id,
11288            verified_access_group_id: v.verified_access_group_id,
11289            application_domain: v.application_domain,
11290            endpoint_type: v.endpoint_type,
11291            attachment_type: v.attachment_type,
11292            domain_certificate_arn: v.domain_certificate_arn,
11293            endpoint_domain: v.endpoint_domain,
11294            device_validation_domain: v.device_validation_domain,
11295            security_group_ids: v.security_group_ids,
11296            load_balancer_options: v
11297                .load_balancer_options
11298                .map(VerifiedAccessEndpointLoadBalancerOptions::from),
11299            network_interface_options: v
11300                .network_interface_options
11301                .map(VerifiedAccessEndpointEniOptions::from),
11302            cidr_options: v.cidr_options.map(VerifiedAccessEndpointCidrOptions::from),
11303            rds_options: v.rds_options.map(VerifiedAccessEndpointRdsOptions::from),
11304            status_code: v.status_code,
11305            status_message: v.status_message,
11306            description: v.description,
11307            creation_time: v.creation_time,
11308            last_updated_time: v.last_updated_time,
11309            deletion_time: v.deletion_time,
11310            sse_specification: VerifiedAccessSseSpecification::from(v.sse_specification),
11311            policy_document: v.policy_document,
11312            policy_enabled: v.policy_enabled,
11313            tags: v.tags,
11314        }
11315    }
11316}
11317
11318impl From<&VerifiedAccessTrustProviderAttachment> for VerifiedAccessTrustProviderAttachmentView {
11319    fn from(a: &VerifiedAccessTrustProviderAttachment) -> Self {
11320        VerifiedAccessTrustProviderAttachmentView {
11321            instance_id: a.instance_id.clone(),
11322            trust_provider_id: a.trust_provider_id.clone(),
11323        }
11324    }
11325}
11326
11327impl From<VerifiedAccessTrustProviderAttachmentView> for VerifiedAccessTrustProviderAttachment {
11328    fn from(v: VerifiedAccessTrustProviderAttachmentView) -> Self {
11329        VerifiedAccessTrustProviderAttachment {
11330            instance_id: v.instance_id,
11331            trust_provider_id: v.trust_provider_id,
11332        }
11333    }
11334}
11335
11336impl From<&VerifiedAccessLogs> for VerifiedAccessLogsView {
11337    fn from(l: &VerifiedAccessLogs) -> Self {
11338        VerifiedAccessLogsView {
11339            cloud_watch_logs_enabled: l.cloud_watch_logs_enabled,
11340            cloud_watch_logs_log_group: l.cloud_watch_logs_log_group.clone(),
11341            kinesis_data_firehose_enabled: l.kinesis_data_firehose_enabled,
11342            kinesis_data_firehose_delivery_stream: l.kinesis_data_firehose_delivery_stream.clone(),
11343            s3_enabled: l.s3_enabled,
11344            s3_bucket_name: l.s3_bucket_name.clone(),
11345            s3_bucket_owner: l.s3_bucket_owner.clone(),
11346            s3_prefix: l.s3_prefix.clone(),
11347            log_version: l.log_version.clone(),
11348            include_trust_context: l.include_trust_context,
11349        }
11350    }
11351}
11352
11353impl From<VerifiedAccessLogsView> for VerifiedAccessLogs {
11354    fn from(v: VerifiedAccessLogsView) -> Self {
11355        VerifiedAccessLogs {
11356            cloud_watch_logs_enabled: v.cloud_watch_logs_enabled,
11357            cloud_watch_logs_log_group: v.cloud_watch_logs_log_group,
11358            kinesis_data_firehose_enabled: v.kinesis_data_firehose_enabled,
11359            kinesis_data_firehose_delivery_stream: v.kinesis_data_firehose_delivery_stream,
11360            s3_enabled: v.s3_enabled,
11361            s3_bucket_name: v.s3_bucket_name,
11362            s3_bucket_owner: v.s3_bucket_owner,
11363            s3_prefix: v.s3_prefix,
11364            log_version: v.log_version,
11365            include_trust_context: v.include_trust_context,
11366        }
11367    }
11368}
11369
11370// ---------------------------------------------------------------------------
11371// Group 12: IPAM view types
11372// ---------------------------------------------------------------------------
11373
11374#[derive(Debug, Clone, Serialize, Deserialize)]
11375pub struct IpamOperatingRegionView {
11376    pub region_name: String,
11377}
11378
11379impl From<&IpamOperatingRegion> for IpamOperatingRegionView {
11380    fn from(r: &IpamOperatingRegion) -> Self {
11381        Self {
11382            region_name: r.region_name.clone(),
11383        }
11384    }
11385}
11386
11387impl From<IpamOperatingRegionView> for IpamOperatingRegion {
11388    fn from(v: IpamOperatingRegionView) -> Self {
11389        Self {
11390            region_name: v.region_name,
11391        }
11392    }
11393}
11394
11395#[derive(Debug, Clone, Serialize, Deserialize)]
11396pub struct IpamView {
11397    pub ipam_id: String,
11398    pub ipam_arn: String,
11399    pub ipam_region: String,
11400    pub public_default_scope_id: String,
11401    pub private_default_scope_id: String,
11402    pub scope_count: i32,
11403    #[serde(default)]
11404    pub description: Option<String>,
11405    #[serde(default)]
11406    pub operating_regions: Vec<IpamOperatingRegionView>,
11407    pub state: String,
11408    pub owner_id: String,
11409    #[serde(default)]
11410    pub default_resource_discovery_id: Option<String>,
11411    #[serde(default)]
11412    pub default_resource_discovery_association_id: Option<String>,
11413    pub resource_discovery_association_count: i32,
11414    pub tier: String,
11415    pub enable_private_gua: bool,
11416    pub metered_account: String,
11417    #[serde(default)]
11418    pub tags: HashMap<String, String>,
11419}
11420
11421impl From<&Ipam> for IpamView {
11422    fn from(i: &Ipam) -> Self {
11423        IpamView {
11424            ipam_id: i.ipam_id.clone(),
11425            ipam_arn: i.ipam_arn.clone(),
11426            ipam_region: i.ipam_region.clone(),
11427            public_default_scope_id: i.public_default_scope_id.clone(),
11428            private_default_scope_id: i.private_default_scope_id.clone(),
11429            scope_count: i.scope_count,
11430            description: i.description.clone(),
11431            operating_regions: i
11432                .operating_regions
11433                .iter()
11434                .map(IpamOperatingRegionView::from)
11435                .collect(),
11436            state: i.state.clone(),
11437            owner_id: i.owner_id.clone(),
11438            default_resource_discovery_id: i.default_resource_discovery_id.clone(),
11439            default_resource_discovery_association_id: i
11440                .default_resource_discovery_association_id
11441                .clone(),
11442            resource_discovery_association_count: i.resource_discovery_association_count,
11443            tier: i.tier.clone(),
11444            enable_private_gua: i.enable_private_gua,
11445            metered_account: i.metered_account.clone(),
11446            tags: i.tags.clone(),
11447        }
11448    }
11449}
11450
11451impl From<IpamView> for Ipam {
11452    fn from(v: IpamView) -> Self {
11453        Ipam {
11454            ipam_id: v.ipam_id,
11455            ipam_arn: v.ipam_arn,
11456            ipam_region: v.ipam_region,
11457            public_default_scope_id: v.public_default_scope_id,
11458            private_default_scope_id: v.private_default_scope_id,
11459            scope_count: v.scope_count,
11460            description: v.description,
11461            operating_regions: v
11462                .operating_regions
11463                .into_iter()
11464                .map(IpamOperatingRegion::from)
11465                .collect(),
11466            state: v.state,
11467            owner_id: v.owner_id,
11468            default_resource_discovery_id: v.default_resource_discovery_id,
11469            default_resource_discovery_association_id: v.default_resource_discovery_association_id,
11470            resource_discovery_association_count: v.resource_discovery_association_count,
11471            tier: v.tier,
11472            enable_private_gua: v.enable_private_gua,
11473            metered_account: v.metered_account,
11474            tags: v.tags,
11475        }
11476    }
11477}
11478
11479#[derive(Debug, Clone, Serialize, Deserialize)]
11480pub struct IpamScopeView {
11481    pub ipam_scope_id: String,
11482    pub ipam_scope_arn: String,
11483    pub ipam_arn: String,
11484    pub ipam_region: String,
11485    pub ipam_scope_type: String,
11486    pub is_default: bool,
11487    #[serde(default)]
11488    pub description: Option<String>,
11489    pub pool_count: i32,
11490    pub state: String,
11491    #[serde(default)]
11492    pub tags: HashMap<String, String>,
11493    pub owner_id: String,
11494}
11495
11496impl From<&IpamScope> for IpamScopeView {
11497    fn from(s: &IpamScope) -> Self {
11498        IpamScopeView {
11499            ipam_scope_id: s.ipam_scope_id.clone(),
11500            ipam_scope_arn: s.ipam_scope_arn.clone(),
11501            ipam_arn: s.ipam_arn.clone(),
11502            ipam_region: s.ipam_region.clone(),
11503            ipam_scope_type: s.ipam_scope_type.clone(),
11504            is_default: s.is_default,
11505            description: s.description.clone(),
11506            pool_count: s.pool_count,
11507            state: s.state.clone(),
11508            tags: s.tags.clone(),
11509            owner_id: s.owner_id.clone(),
11510        }
11511    }
11512}
11513
11514impl From<IpamScopeView> for IpamScope {
11515    fn from(v: IpamScopeView) -> Self {
11516        IpamScope {
11517            ipam_scope_id: v.ipam_scope_id,
11518            ipam_scope_arn: v.ipam_scope_arn,
11519            ipam_arn: v.ipam_arn,
11520            ipam_region: v.ipam_region,
11521            ipam_scope_type: v.ipam_scope_type,
11522            is_default: v.is_default,
11523            description: v.description,
11524            pool_count: v.pool_count,
11525            state: v.state,
11526            tags: v.tags,
11527            owner_id: v.owner_id,
11528        }
11529    }
11530}
11531
11532#[derive(Debug, Clone, Serialize, Deserialize)]
11533pub struct IpamPoolView {
11534    pub ipam_pool_id: String,
11535    #[serde(default)]
11536    pub source_ipam_pool_id: Option<String>,
11537    pub ipam_pool_arn: String,
11538    pub ipam_scope_arn: String,
11539    pub ipam_scope_type: String,
11540    pub ipam_arn: String,
11541    pub ipam_region: String,
11542    pub locale: String,
11543    pub pool_depth: i32,
11544    pub state: String,
11545    #[serde(default)]
11546    pub state_message: Option<String>,
11547    #[serde(default)]
11548    pub description: Option<String>,
11549    pub auto_import: bool,
11550    pub publicly_advertisable: bool,
11551    pub address_family: String,
11552    #[serde(default)]
11553    pub allocation_min_netmask_length: Option<i32>,
11554    #[serde(default)]
11555    pub allocation_max_netmask_length: Option<i32>,
11556    #[serde(default)]
11557    pub allocation_default_netmask_length: Option<i32>,
11558    #[serde(default)]
11559    pub allocation_resource_tags: Vec<(String, String)>,
11560    #[serde(default)]
11561    pub aws_service: Option<String>,
11562    #[serde(default)]
11563    pub public_ip_source: Option<String>,
11564    #[serde(default)]
11565    pub source_resource_id: Option<String>,
11566    #[serde(default)]
11567    pub source_resource_type: Option<String>,
11568    #[serde(default)]
11569    pub source_resource_region: Option<String>,
11570    #[serde(default)]
11571    pub source_resource_owner: Option<String>,
11572    #[serde(default)]
11573    pub tags: HashMap<String, String>,
11574    pub owner_id: String,
11575    pub allocation_count: i32,
11576}
11577
11578impl From<&IpamPool> for IpamPoolView {
11579    fn from(p: &IpamPool) -> Self {
11580        IpamPoolView {
11581            ipam_pool_id: p.ipam_pool_id.clone(),
11582            source_ipam_pool_id: p.source_ipam_pool_id.clone(),
11583            ipam_pool_arn: p.ipam_pool_arn.clone(),
11584            ipam_scope_arn: p.ipam_scope_arn.clone(),
11585            ipam_scope_type: p.ipam_scope_type.clone(),
11586            ipam_arn: p.ipam_arn.clone(),
11587            ipam_region: p.ipam_region.clone(),
11588            locale: p.locale.clone(),
11589            pool_depth: p.pool_depth,
11590            state: p.state.clone(),
11591            state_message: p.state_message.clone(),
11592            description: p.description.clone(),
11593            auto_import: p.auto_import,
11594            publicly_advertisable: p.publicly_advertisable,
11595            address_family: p.address_family.clone(),
11596            allocation_min_netmask_length: p.allocation_min_netmask_length,
11597            allocation_max_netmask_length: p.allocation_max_netmask_length,
11598            allocation_default_netmask_length: p.allocation_default_netmask_length,
11599            allocation_resource_tags: p.allocation_resource_tags.clone(),
11600            aws_service: p.aws_service.clone(),
11601            public_ip_source: p.public_ip_source.clone(),
11602            source_resource_id: p.source_resource_id.clone(),
11603            source_resource_type: p.source_resource_type.clone(),
11604            source_resource_region: p.source_resource_region.clone(),
11605            source_resource_owner: p.source_resource_owner.clone(),
11606            tags: p.tags.clone(),
11607            owner_id: p.owner_id.clone(),
11608            allocation_count: p.allocation_count,
11609        }
11610    }
11611}
11612
11613impl From<IpamPoolView> for IpamPool {
11614    fn from(v: IpamPoolView) -> Self {
11615        IpamPool {
11616            ipam_pool_id: v.ipam_pool_id,
11617            source_ipam_pool_id: v.source_ipam_pool_id,
11618            ipam_pool_arn: v.ipam_pool_arn,
11619            ipam_scope_arn: v.ipam_scope_arn,
11620            ipam_scope_type: v.ipam_scope_type,
11621            ipam_arn: v.ipam_arn,
11622            ipam_region: v.ipam_region,
11623            locale: v.locale,
11624            pool_depth: v.pool_depth,
11625            state: v.state,
11626            state_message: v.state_message,
11627            description: v.description,
11628            auto_import: v.auto_import,
11629            publicly_advertisable: v.publicly_advertisable,
11630            address_family: v.address_family,
11631            allocation_min_netmask_length: v.allocation_min_netmask_length,
11632            allocation_max_netmask_length: v.allocation_max_netmask_length,
11633            allocation_default_netmask_length: v.allocation_default_netmask_length,
11634            allocation_resource_tags: v.allocation_resource_tags,
11635            aws_service: v.aws_service,
11636            public_ip_source: v.public_ip_source,
11637            source_resource_id: v.source_resource_id,
11638            source_resource_type: v.source_resource_type,
11639            source_resource_region: v.source_resource_region,
11640            source_resource_owner: v.source_resource_owner,
11641            tags: v.tags,
11642            owner_id: v.owner_id,
11643            allocation_count: v.allocation_count,
11644        }
11645    }
11646}
11647
11648#[derive(Debug, Clone, Serialize, Deserialize)]
11649pub struct IpamPoolCidrView {
11650    pub ipam_pool_id: String,
11651    pub cidr: String,
11652    pub state: String,
11653    #[serde(default)]
11654    pub failure_reason: Option<String>,
11655    pub ipam_pool_cidr_id: String,
11656    #[serde(default)]
11657    pub netmask_length: Option<i32>,
11658}
11659
11660impl IpamPoolCidrView {
11661    pub fn from_kv(key: &(String, String), c: &IpamPoolCidr) -> Self {
11662        IpamPoolCidrView {
11663            ipam_pool_id: key.0.clone(),
11664            cidr: c.cidr.clone(),
11665            state: c.state.clone(),
11666            failure_reason: c.failure_reason.clone(),
11667            ipam_pool_cidr_id: c.ipam_pool_cidr_id.clone(),
11668            netmask_length: c.netmask_length,
11669        }
11670    }
11671}
11672
11673impl From<IpamPoolCidrView> for IpamPoolCidr {
11674    fn from(v: IpamPoolCidrView) -> Self {
11675        IpamPoolCidr {
11676            cidr: v.cidr,
11677            state: v.state,
11678            failure_reason: v.failure_reason,
11679            ipam_pool_cidr_id: v.ipam_pool_cidr_id,
11680            netmask_length: v.netmask_length,
11681        }
11682    }
11683}
11684
11685#[derive(Debug, Clone, Serialize, Deserialize)]
11686pub struct IpamPoolAllocationView {
11687    pub ipam_pool_allocation_id: String,
11688    pub cidr: String,
11689    pub ipam_pool_id: String,
11690    #[serde(default)]
11691    pub description: Option<String>,
11692    #[serde(default)]
11693    pub resource_id: Option<String>,
11694    pub resource_type: String,
11695    #[serde(default)]
11696    pub resource_region: Option<String>,
11697    #[serde(default)]
11698    pub resource_owner: Option<String>,
11699}
11700
11701impl From<&IpamPoolAllocation> for IpamPoolAllocationView {
11702    fn from(a: &IpamPoolAllocation) -> Self {
11703        IpamPoolAllocationView {
11704            ipam_pool_allocation_id: a.ipam_pool_allocation_id.clone(),
11705            cidr: a.cidr.clone(),
11706            ipam_pool_id: a.ipam_pool_id.clone(),
11707            description: a.description.clone(),
11708            resource_id: a.resource_id.clone(),
11709            resource_type: a.resource_type.clone(),
11710            resource_region: a.resource_region.clone(),
11711            resource_owner: a.resource_owner.clone(),
11712        }
11713    }
11714}
11715
11716impl From<IpamPoolAllocationView> for IpamPoolAllocation {
11717    fn from(v: IpamPoolAllocationView) -> Self {
11718        IpamPoolAllocation {
11719            ipam_pool_allocation_id: v.ipam_pool_allocation_id,
11720            cidr: v.cidr,
11721            ipam_pool_id: v.ipam_pool_id,
11722            description: v.description,
11723            resource_id: v.resource_id,
11724            resource_type: v.resource_type,
11725            resource_region: v.resource_region,
11726            resource_owner: v.resource_owner,
11727        }
11728    }
11729}
11730
11731#[derive(Debug, Clone, Serialize, Deserialize)]
11732pub struct IpamResourceDiscoveryView {
11733    pub ipam_resource_discovery_id: String,
11734    pub ipam_resource_discovery_arn: String,
11735    pub ipam_resource_discovery_region: String,
11736    #[serde(default)]
11737    pub description: Option<String>,
11738    #[serde(default)]
11739    pub operating_regions: Vec<IpamOperatingRegionView>,
11740    pub is_default: bool,
11741    pub state: String,
11742    pub owner_id: String,
11743    #[serde(default)]
11744    pub tags: HashMap<String, String>,
11745}
11746
11747impl From<&IpamResourceDiscovery> for IpamResourceDiscoveryView {
11748    fn from(r: &IpamResourceDiscovery) -> Self {
11749        IpamResourceDiscoveryView {
11750            ipam_resource_discovery_id: r.ipam_resource_discovery_id.clone(),
11751            ipam_resource_discovery_arn: r.ipam_resource_discovery_arn.clone(),
11752            ipam_resource_discovery_region: r.ipam_resource_discovery_region.clone(),
11753            description: r.description.clone(),
11754            operating_regions: r
11755                .operating_regions
11756                .iter()
11757                .map(IpamOperatingRegionView::from)
11758                .collect(),
11759            is_default: r.is_default,
11760            state: r.state.clone(),
11761            owner_id: r.owner_id.clone(),
11762            tags: r.tags.clone(),
11763        }
11764    }
11765}
11766
11767impl From<IpamResourceDiscoveryView> for IpamResourceDiscovery {
11768    fn from(v: IpamResourceDiscoveryView) -> Self {
11769        IpamResourceDiscovery {
11770            ipam_resource_discovery_id: v.ipam_resource_discovery_id,
11771            ipam_resource_discovery_arn: v.ipam_resource_discovery_arn,
11772            ipam_resource_discovery_region: v.ipam_resource_discovery_region,
11773            description: v.description,
11774            operating_regions: v
11775                .operating_regions
11776                .into_iter()
11777                .map(IpamOperatingRegion::from)
11778                .collect(),
11779            is_default: v.is_default,
11780            state: v.state,
11781            owner_id: v.owner_id,
11782            tags: v.tags,
11783        }
11784    }
11785}
11786
11787#[derive(Debug, Clone, Serialize, Deserialize)]
11788pub struct IpamResourceDiscoveryAssociationView {
11789    pub ipam_resource_discovery_association_id: String,
11790    pub ipam_resource_discovery_association_arn: String,
11791    pub ipam_arn: String,
11792    pub ipam_id: String,
11793    pub ipam_region: String,
11794    pub ipam_resource_discovery_id: String,
11795    pub owner_id: String,
11796    pub is_default: bool,
11797    pub resource_discovery_status: String,
11798    pub state: String,
11799    #[serde(default)]
11800    pub tags: HashMap<String, String>,
11801}
11802
11803impl From<&IpamResourceDiscoveryAssociation> for IpamResourceDiscoveryAssociationView {
11804    fn from(a: &IpamResourceDiscoveryAssociation) -> Self {
11805        IpamResourceDiscoveryAssociationView {
11806            ipam_resource_discovery_association_id: a
11807                .ipam_resource_discovery_association_id
11808                .clone(),
11809            ipam_resource_discovery_association_arn: a
11810                .ipam_resource_discovery_association_arn
11811                .clone(),
11812            ipam_arn: a.ipam_arn.clone(),
11813            ipam_id: a.ipam_id.clone(),
11814            ipam_region: a.ipam_region.clone(),
11815            ipam_resource_discovery_id: a.ipam_resource_discovery_id.clone(),
11816            owner_id: a.owner_id.clone(),
11817            is_default: a.is_default,
11818            resource_discovery_status: a.resource_discovery_status.clone(),
11819            state: a.state.clone(),
11820            tags: a.tags.clone(),
11821        }
11822    }
11823}
11824
11825impl From<IpamResourceDiscoveryAssociationView> for IpamResourceDiscoveryAssociation {
11826    fn from(v: IpamResourceDiscoveryAssociationView) -> Self {
11827        IpamResourceDiscoveryAssociation {
11828            ipam_resource_discovery_association_id: v.ipam_resource_discovery_association_id,
11829            ipam_resource_discovery_association_arn: v.ipam_resource_discovery_association_arn,
11830            ipam_arn: v.ipam_arn,
11831            ipam_id: v.ipam_id,
11832            ipam_region: v.ipam_region,
11833            ipam_resource_discovery_id: v.ipam_resource_discovery_id,
11834            owner_id: v.owner_id,
11835            is_default: v.is_default,
11836            resource_discovery_status: v.resource_discovery_status,
11837            state: v.state,
11838            tags: v.tags,
11839        }
11840    }
11841}
11842
11843#[derive(Debug, Clone, Serialize, Deserialize)]
11844pub struct IpamByoasnView {
11845    pub asn: String,
11846    pub ipam_id: String,
11847    #[serde(default)]
11848    pub description: Option<String>,
11849    pub state: String,
11850    #[serde(default)]
11851    pub status_message: Option<String>,
11852}
11853
11854impl From<&IpamByoasn> for IpamByoasnView {
11855    fn from(b: &IpamByoasn) -> Self {
11856        IpamByoasnView {
11857            asn: b.asn.clone(),
11858            ipam_id: b.ipam_id.clone(),
11859            description: b.description.clone(),
11860            state: b.state.clone(),
11861            status_message: b.status_message.clone(),
11862        }
11863    }
11864}
11865
11866impl From<IpamByoasnView> for IpamByoasn {
11867    fn from(v: IpamByoasnView) -> Self {
11868        IpamByoasn {
11869            asn: v.asn,
11870            ipam_id: v.ipam_id,
11871            description: v.description,
11872            state: v.state,
11873            status_message: v.status_message,
11874        }
11875    }
11876}
11877
11878#[derive(Debug, Clone, Serialize, Deserialize)]
11879pub struct IpamExternalResourceVerificationTokenView {
11880    pub ipam_external_resource_verification_token_id: String,
11881    pub ipam_external_resource_verification_token_arn: String,
11882    pub ipam_id: String,
11883    pub ipam_arn: String,
11884    pub ipam_region: String,
11885    pub token_value: String,
11886    pub token_name: String,
11887    pub not_after: String,
11888    pub status: String,
11889    pub state: String,
11890    #[serde(default)]
11891    pub tags: HashMap<String, String>,
11892}
11893
11894impl From<&IpamExternalResourceVerificationToken> for IpamExternalResourceVerificationTokenView {
11895    fn from(t: &IpamExternalResourceVerificationToken) -> Self {
11896        IpamExternalResourceVerificationTokenView {
11897            ipam_external_resource_verification_token_id: t
11898                .ipam_external_resource_verification_token_id
11899                .clone(),
11900            ipam_external_resource_verification_token_arn: t
11901                .ipam_external_resource_verification_token_arn
11902                .clone(),
11903            ipam_id: t.ipam_id.clone(),
11904            ipam_arn: t.ipam_arn.clone(),
11905            ipam_region: t.ipam_region.clone(),
11906            token_value: t.token_value.clone(),
11907            token_name: t.token_name.clone(),
11908            not_after: t.not_after.clone(),
11909            status: t.status.clone(),
11910            state: t.state.clone(),
11911            tags: t.tags.clone(),
11912        }
11913    }
11914}
11915
11916impl From<IpamExternalResourceVerificationTokenView> for IpamExternalResourceVerificationToken {
11917    fn from(v: IpamExternalResourceVerificationTokenView) -> Self {
11918        IpamExternalResourceVerificationToken {
11919            ipam_external_resource_verification_token_id: v
11920                .ipam_external_resource_verification_token_id,
11921            ipam_external_resource_verification_token_arn: v
11922                .ipam_external_resource_verification_token_arn,
11923            ipam_id: v.ipam_id,
11924            ipam_arn: v.ipam_arn,
11925            ipam_region: v.ipam_region,
11926            token_value: v.token_value,
11927            token_name: v.token_name,
11928            not_after: v.not_after,
11929            status: v.status,
11930            state: v.state,
11931            tags: v.tags,
11932        }
11933    }
11934}
11935
11936#[derive(Debug, Clone, Serialize, Deserialize)]
11937pub struct IpamPolicyAllocationRuleView {
11938    #[serde(default)]
11939    pub source_ipam_pool_id: Option<String>,
11940}
11941
11942impl From<&IpamPolicyAllocationRule> for IpamPolicyAllocationRuleView {
11943    fn from(r: &IpamPolicyAllocationRule) -> Self {
11944        Self {
11945            source_ipam_pool_id: r.source_ipam_pool_id.clone(),
11946        }
11947    }
11948}
11949
11950impl From<IpamPolicyAllocationRuleView> for IpamPolicyAllocationRule {
11951    fn from(v: IpamPolicyAllocationRuleView) -> Self {
11952        Self {
11953            source_ipam_pool_id: v.source_ipam_pool_id,
11954        }
11955    }
11956}
11957
11958#[derive(Debug, Clone, Serialize, Deserialize)]
11959pub struct IpamPolicyView {
11960    pub ipam_policy_id: String,
11961    pub ipam_policy_arn: String,
11962    pub ipam_arn: String,
11963    pub ipam_region: String,
11964    pub policy_name: String,
11965    pub policy_type: String,
11966    #[serde(default)]
11967    pub description: Option<String>,
11968    pub state: String,
11969    #[serde(default)]
11970    pub allocation_rules: Vec<IpamPolicyAllocationRuleView>,
11971    #[serde(default)]
11972    pub tags: HashMap<String, String>,
11973    pub owner_id: String,
11974}
11975
11976impl From<&IpamPolicy> for IpamPolicyView {
11977    fn from(p: &IpamPolicy) -> Self {
11978        IpamPolicyView {
11979            ipam_policy_id: p.ipam_policy_id.clone(),
11980            ipam_policy_arn: p.ipam_policy_arn.clone(),
11981            ipam_arn: p.ipam_arn.clone(),
11982            ipam_region: p.ipam_region.clone(),
11983            policy_name: p.policy_name.clone(),
11984            policy_type: p.policy_type.clone(),
11985            description: p.description.clone(),
11986            state: p.state.clone(),
11987            allocation_rules: p
11988                .allocation_rules
11989                .iter()
11990                .map(IpamPolicyAllocationRuleView::from)
11991                .collect(),
11992            tags: p.tags.clone(),
11993            owner_id: p.owner_id.clone(),
11994        }
11995    }
11996}
11997
11998impl From<IpamPolicyView> for IpamPolicy {
11999    fn from(v: IpamPolicyView) -> Self {
12000        IpamPolicy {
12001            ipam_policy_id: v.ipam_policy_id,
12002            ipam_policy_arn: v.ipam_policy_arn,
12003            ipam_arn: v.ipam_arn,
12004            ipam_region: v.ipam_region,
12005            policy_name: v.policy_name,
12006            policy_type: v.policy_type,
12007            description: v.description,
12008            state: v.state,
12009            allocation_rules: v
12010                .allocation_rules
12011                .into_iter()
12012                .map(IpamPolicyAllocationRule::from)
12013                .collect(),
12014            tags: v.tags,
12015            owner_id: v.owner_id,
12016        }
12017    }
12018}
12019
12020#[derive(Debug, Clone, Serialize, Deserialize)]
12021pub struct IpamPrefixListResolverView {
12022    pub ipam_prefix_list_resolver_id: String,
12023    pub ipam_prefix_list_resolver_arn: String,
12024    pub ipam_arn: String,
12025    pub ipam_region: String,
12026    pub name: String,
12027    #[serde(default)]
12028    pub description: Option<String>,
12029    pub state: String,
12030    pub owner_id: String,
12031    pub target_count: i32,
12032    #[serde(default)]
12033    pub tags: HashMap<String, String>,
12034}
12035
12036impl From<&IpamPrefixListResolver> for IpamPrefixListResolverView {
12037    fn from(r: &IpamPrefixListResolver) -> Self {
12038        IpamPrefixListResolverView {
12039            ipam_prefix_list_resolver_id: r.ipam_prefix_list_resolver_id.clone(),
12040            ipam_prefix_list_resolver_arn: r.ipam_prefix_list_resolver_arn.clone(),
12041            ipam_arn: r.ipam_arn.clone(),
12042            ipam_region: r.ipam_region.clone(),
12043            name: r.name.clone(),
12044            description: r.description.clone(),
12045            state: r.state.clone(),
12046            owner_id: r.owner_id.clone(),
12047            target_count: r.target_count,
12048            tags: r.tags.clone(),
12049        }
12050    }
12051}
12052
12053impl From<IpamPrefixListResolverView> for IpamPrefixListResolver {
12054    fn from(v: IpamPrefixListResolverView) -> Self {
12055        IpamPrefixListResolver {
12056            ipam_prefix_list_resolver_id: v.ipam_prefix_list_resolver_id,
12057            ipam_prefix_list_resolver_arn: v.ipam_prefix_list_resolver_arn,
12058            ipam_arn: v.ipam_arn,
12059            ipam_region: v.ipam_region,
12060            name: v.name,
12061            description: v.description,
12062            state: v.state,
12063            owner_id: v.owner_id,
12064            target_count: v.target_count,
12065            tags: v.tags,
12066        }
12067    }
12068}
12069
12070#[derive(Debug, Clone, Serialize, Deserialize)]
12071pub struct IpamPrefixListResolverTargetView {
12072    pub ipam_prefix_list_resolver_target_id: String,
12073    pub ipam_prefix_list_resolver_id: String,
12074    pub target_resource_arn: String,
12075    pub target_resource_type: String,
12076    pub target_resource_region: String,
12077    pub owner_id: String,
12078    pub state: String,
12079    #[serde(default)]
12080    pub tags: HashMap<String, String>,
12081}
12082
12083impl From<&IpamPrefixListResolverTarget> for IpamPrefixListResolverTargetView {
12084    fn from(t: &IpamPrefixListResolverTarget) -> Self {
12085        IpamPrefixListResolverTargetView {
12086            ipam_prefix_list_resolver_target_id: t.ipam_prefix_list_resolver_target_id.clone(),
12087            ipam_prefix_list_resolver_id: t.ipam_prefix_list_resolver_id.clone(),
12088            target_resource_arn: t.target_resource_arn.clone(),
12089            target_resource_type: t.target_resource_type.clone(),
12090            target_resource_region: t.target_resource_region.clone(),
12091            owner_id: t.owner_id.clone(),
12092            state: t.state.clone(),
12093            tags: t.tags.clone(),
12094        }
12095    }
12096}
12097
12098impl From<IpamPrefixListResolverTargetView> for IpamPrefixListResolverTarget {
12099    fn from(v: IpamPrefixListResolverTargetView) -> Self {
12100        IpamPrefixListResolverTarget {
12101            ipam_prefix_list_resolver_target_id: v.ipam_prefix_list_resolver_target_id,
12102            ipam_prefix_list_resolver_id: v.ipam_prefix_list_resolver_id,
12103            target_resource_arn: v.target_resource_arn,
12104            target_resource_type: v.target_resource_type,
12105            target_resource_region: v.target_resource_region,
12106            owner_id: v.owner_id,
12107            state: v.state,
12108            tags: v.tags,
12109        }
12110    }
12111}
12112
12113// ---------------------------------------------------------------------------
12114// Batch B view types and round-trip From impls.
12115// ---------------------------------------------------------------------------
12116
12117#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12118pub struct VolumeModificationView {
12119    pub volume_id: String,
12120    pub modification_state: String,
12121    #[serde(default)]
12122    pub status_message: Option<String>,
12123    #[serde(default)]
12124    pub target_size: Option<i32>,
12125    #[serde(default)]
12126    pub target_iops: Option<i32>,
12127    #[serde(default)]
12128    pub target_throughput: Option<i32>,
12129    #[serde(default)]
12130    pub target_volume_type: Option<String>,
12131    #[serde(default)]
12132    pub target_multi_attach_enabled: Option<bool>,
12133    #[serde(default)]
12134    pub original_size: Option<i32>,
12135    #[serde(default)]
12136    pub original_iops: Option<i32>,
12137    #[serde(default)]
12138    pub original_throughput: Option<i32>,
12139    #[serde(default)]
12140    pub original_volume_type: Option<String>,
12141    #[serde(default)]
12142    pub original_multi_attach_enabled: Option<bool>,
12143    pub progress: i64,
12144    pub start_time: String,
12145    #[serde(default)]
12146    pub end_time: Option<String>,
12147}
12148
12149impl From<&crate::types::VolumeModification> for VolumeModificationView {
12150    fn from(m: &crate::types::VolumeModification) -> Self {
12151        VolumeModificationView {
12152            volume_id: m.volume_id.clone(),
12153            modification_state: m.modification_state.clone(),
12154            status_message: m.status_message.clone(),
12155            target_size: m.target_size,
12156            target_iops: m.target_iops,
12157            target_throughput: m.target_throughput,
12158            target_volume_type: m.target_volume_type.clone(),
12159            target_multi_attach_enabled: m.target_multi_attach_enabled,
12160            original_size: m.original_size,
12161            original_iops: m.original_iops,
12162            original_throughput: m.original_throughput,
12163            original_volume_type: m.original_volume_type.clone(),
12164            original_multi_attach_enabled: m.original_multi_attach_enabled,
12165            progress: m.progress,
12166            start_time: m.start_time.clone(),
12167            end_time: m.end_time.clone(),
12168        }
12169    }
12170}
12171
12172impl From<VolumeModificationView> for crate::types::VolumeModification {
12173    fn from(v: VolumeModificationView) -> Self {
12174        crate::types::VolumeModification {
12175            volume_id: v.volume_id,
12176            modification_state: v.modification_state,
12177            status_message: v.status_message,
12178            target_size: v.target_size,
12179            target_iops: v.target_iops,
12180            target_throughput: v.target_throughput,
12181            target_volume_type: v.target_volume_type,
12182            target_multi_attach_enabled: v.target_multi_attach_enabled,
12183            original_size: v.original_size,
12184            original_iops: v.original_iops,
12185            original_throughput: v.original_throughput,
12186            original_volume_type: v.original_volume_type,
12187            original_multi_attach_enabled: v.original_multi_attach_enabled,
12188            progress: v.progress,
12189            start_time: v.start_time,
12190            end_time: v.end_time,
12191        }
12192    }
12193}
12194
12195#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12196pub struct ImportVolumeTaskView {
12197    pub conversion_task_id: String,
12198    pub expiration_time: String,
12199    pub image: DiskImageDescriptionView,
12200    pub volume: DiskImageVolumeDescriptionView,
12201    pub availability_zone: String,
12202    pub bytes_converted: i64,
12203    #[serde(default)]
12204    pub description: Option<String>,
12205    pub status: String,
12206    #[serde(default)]
12207    pub status_message: Option<String>,
12208}
12209
12210#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12211pub struct DiskImageDescriptionView {
12212    pub format: String,
12213    pub size: i64,
12214    pub import_manifest_url: String,
12215    #[serde(default)]
12216    pub checksum: Option<String>,
12217}
12218
12219#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12220pub struct DiskImageVolumeDescriptionView {
12221    pub size: i64,
12222    pub id: String,
12223}
12224
12225impl From<&crate::types::ImportVolumeTask> for ImportVolumeTaskView {
12226    fn from(t: &crate::types::ImportVolumeTask) -> Self {
12227        ImportVolumeTaskView {
12228            conversion_task_id: t.conversion_task_id.clone(),
12229            expiration_time: t.expiration_time.clone(),
12230            image: DiskImageDescriptionView {
12231                format: t.image.format.clone(),
12232                size: t.image.size,
12233                import_manifest_url: t.image.import_manifest_url.clone(),
12234                checksum: t.image.checksum.clone(),
12235            },
12236            volume: DiskImageVolumeDescriptionView {
12237                size: t.volume.size,
12238                id: t.volume.id.clone(),
12239            },
12240            availability_zone: t.availability_zone.clone(),
12241            bytes_converted: t.bytes_converted,
12242            description: t.description.clone(),
12243            status: t.status.clone(),
12244            status_message: t.status_message.clone(),
12245        }
12246    }
12247}
12248
12249impl From<ImportVolumeTaskView> for crate::types::ImportVolumeTask {
12250    fn from(v: ImportVolumeTaskView) -> Self {
12251        crate::types::ImportVolumeTask {
12252            conversion_task_id: v.conversion_task_id,
12253            expiration_time: v.expiration_time,
12254            image: crate::types::DiskImageDescription {
12255                format: v.image.format,
12256                size: v.image.size,
12257                import_manifest_url: v.image.import_manifest_url,
12258                checksum: v.image.checksum,
12259            },
12260            volume: crate::types::DiskImageVolumeDescription {
12261                size: v.volume.size,
12262                id: v.volume.id,
12263            },
12264            availability_zone: v.availability_zone,
12265            bytes_converted: v.bytes_converted,
12266            description: v.description,
12267            status: v.status,
12268            status_message: v.status_message,
12269        }
12270    }
12271}
12272
12273#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12274pub struct BundleTaskView {
12275    pub bundle_id: String,
12276    pub instance_id: String,
12277    pub bucket: String,
12278    pub prefix: String,
12279    pub start_time: String,
12280    pub update_time: String,
12281    pub state: String,
12282    pub progress: String,
12283    #[serde(default)]
12284    pub error_code: Option<String>,
12285    #[serde(default)]
12286    pub error_message: Option<String>,
12287}
12288
12289impl From<&crate::types::BundleTask> for BundleTaskView {
12290    fn from(t: &crate::types::BundleTask) -> Self {
12291        BundleTaskView {
12292            bundle_id: t.bundle_id.clone(),
12293            instance_id: t.instance_id.clone(),
12294            bucket: t.bucket.clone(),
12295            prefix: t.prefix.clone(),
12296            start_time: t.start_time.clone(),
12297            update_time: t.update_time.clone(),
12298            state: t.state.clone(),
12299            progress: t.progress.clone(),
12300            error_code: t.error_code.clone(),
12301            error_message: t.error_message.clone(),
12302        }
12303    }
12304}
12305
12306impl From<BundleTaskView> for crate::types::BundleTask {
12307    fn from(v: BundleTaskView) -> Self {
12308        crate::types::BundleTask {
12309            bundle_id: v.bundle_id,
12310            instance_id: v.instance_id,
12311            bucket: v.bucket,
12312            prefix: v.prefix,
12313            start_time: v.start_time,
12314            update_time: v.update_time,
12315            state: v.state,
12316            progress: v.progress,
12317            error_code: v.error_code,
12318            error_message: v.error_message,
12319        }
12320    }
12321}
12322
12323#[derive(Debug, Clone, Serialize, Deserialize)]
12324pub struct IdFormatEntryView {
12325    pub use_long_ids: bool,
12326    #[serde(default)]
12327    pub deadline: Option<String>,
12328}
12329
12330impl From<&crate::types::IdFormatEntry> for IdFormatEntryView {
12331    fn from(e: &crate::types::IdFormatEntry) -> Self {
12332        IdFormatEntryView {
12333            use_long_ids: e.use_long_ids,
12334            deadline: e.deadline.clone(),
12335        }
12336    }
12337}
12338
12339impl From<IdFormatEntryView> for crate::types::IdFormatEntry {
12340    fn from(v: IdFormatEntryView) -> Self {
12341        crate::types::IdFormatEntry {
12342            use_long_ids: v.use_long_ids,
12343            deadline: v.deadline,
12344        }
12345    }
12346}
12347
12348#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12349pub struct OutpostLagView {
12350    pub outpost_lag_id: String,
12351    pub outpost_arn: String,
12352    pub owner_id: String,
12353    pub state: String,
12354    #[serde(default)]
12355    pub local_gateway_virtual_interface_ids: Vec<String>,
12356    #[serde(default)]
12357    pub service_link_virtual_interface_ids: Vec<String>,
12358    #[serde(default)]
12359    pub tags: HashMap<String, String>,
12360}
12361
12362impl From<&crate::types::OutpostLag> for OutpostLagView {
12363    fn from(l: &crate::types::OutpostLag) -> Self {
12364        OutpostLagView {
12365            outpost_lag_id: l.outpost_lag_id.clone(),
12366            outpost_arn: l.outpost_arn.clone(),
12367            owner_id: l.owner_id.clone(),
12368            state: l.state.clone(),
12369            local_gateway_virtual_interface_ids: l.local_gateway_virtual_interface_ids.clone(),
12370            service_link_virtual_interface_ids: l.service_link_virtual_interface_ids.clone(),
12371            tags: l.tags.clone(),
12372        }
12373    }
12374}
12375
12376impl From<OutpostLagView> for crate::types::OutpostLag {
12377    fn from(v: OutpostLagView) -> Self {
12378        crate::types::OutpostLag {
12379            outpost_lag_id: v.outpost_lag_id,
12380            outpost_arn: v.outpost_arn,
12381            owner_id: v.owner_id,
12382            state: v.state,
12383            local_gateway_virtual_interface_ids: v.local_gateway_virtual_interface_ids,
12384            service_link_virtual_interface_ids: v.service_link_virtual_interface_ids,
12385            tags: v.tags,
12386        }
12387    }
12388}
12389
12390#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12391pub struct ExportImageTaskView {
12392    pub export_image_task_id: String,
12393    #[serde(default)]
12394    pub description: Option<String>,
12395    pub image_id: String,
12396    pub role_name: String,
12397    pub status: String,
12398    #[serde(default)]
12399    pub status_message: Option<String>,
12400    pub progress: String,
12401    pub s3_export_location: ExportTaskS3LocationView,
12402    pub disk_image_format: String,
12403    #[serde(default)]
12404    pub tags: HashMap<String, String>,
12405}
12406
12407#[derive(Debug, Clone, Default, Serialize, Deserialize)]
12408pub struct ExportTaskS3LocationView {
12409    pub s3_bucket: String,
12410    #[serde(default)]
12411    pub s3_prefix: Option<String>,
12412}
12413
12414impl From<&crate::types::ExportImageTask> for ExportImageTaskView {
12415    fn from(t: &crate::types::ExportImageTask) -> Self {
12416        ExportImageTaskView {
12417            export_image_task_id: t.export_image_task_id.clone(),
12418            description: t.description.clone(),
12419            image_id: t.image_id.clone(),
12420            role_name: t.role_name.clone(),
12421            status: t.status.clone(),
12422            status_message: t.status_message.clone(),
12423            progress: t.progress.clone(),
12424            s3_export_location: ExportTaskS3LocationView {
12425                s3_bucket: t.s3_export_location.s3_bucket.clone(),
12426                s3_prefix: t.s3_export_location.s3_prefix.clone(),
12427            },
12428            disk_image_format: t.disk_image_format.clone(),
12429            tags: t.tags.clone(),
12430        }
12431    }
12432}
12433
12434impl From<ExportImageTaskView> for crate::types::ExportImageTask {
12435    fn from(v: ExportImageTaskView) -> Self {
12436        crate::types::ExportImageTask {
12437            export_image_task_id: v.export_image_task_id,
12438            description: v.description,
12439            image_id: v.image_id,
12440            role_name: v.role_name,
12441            status: v.status,
12442            status_message: v.status_message,
12443            progress: v.progress,
12444            s3_export_location: crate::types::ExportTaskS3Location {
12445                s3_bucket: v.s3_export_location.s3_bucket,
12446                s3_prefix: v.s3_export_location.s3_prefix,
12447            },
12448            disk_image_format: v.disk_image_format,
12449            tags: v.tags,
12450        }
12451    }
12452}
12453
12454// ---------------------------------------------------------------------------
12455// StatefulService implementation
12456// ---------------------------------------------------------------------------
12457
12458impl StatefulService for Ec2Service {
12459    type StateView = Ec2StateView;
12460
12461    async fn snapshot(&self, account_id: &str, region: &str) -> Self::StateView {
12462        let state = self.state.get(account_id, region);
12463        let guard = state.read().await;
12464        Ec2StateView::from(&*guard)
12465    }
12466
12467    async fn restore(
12468        &self,
12469        account_id: &str,
12470        region: &str,
12471        view: Self::StateView,
12472    ) -> Result<(), StateViewError> {
12473        let state = self.state.get(account_id, region);
12474        {
12475            let mut guard = state.write().await;
12476            *guard = Ec2State::from(view);
12477        }
12478        self.notify_state_changed(account_id, region).await;
12479        Ok(())
12480    }
12481
12482    async fn merge(
12483        &self,
12484        account_id: &str,
12485        region: &str,
12486        view: Self::StateView,
12487    ) -> Result<(), StateViewError> {
12488        let state = self.state.get(account_id, region);
12489        {
12490            let mut guard = state.write().await;
12491            for (k, v) in view.vpcs {
12492                guard.vpcs.insert(k, Vpc::from(v));
12493            }
12494            for (k, v) in view.subnets {
12495                guard.subnets.insert(k, Subnet::from(v));
12496            }
12497            for (k, v) in view.igws {
12498                guard.igws.insert(k, InternetGateway::from(v));
12499            }
12500            for (k, v) in view.security_groups {
12501                guard.security_groups.insert(k, SecurityGroup::from(v));
12502            }
12503            for (k, v) in view.route_tables {
12504                guard.route_tables.insert(k, RouteTable::from(v));
12505            }
12506            for (k, v) in view.key_pairs {
12507                guard.key_pairs.insert(k, KeyPair::from(v));
12508            }
12509            for (k, v) in view.network_acls {
12510                guard.network_acls.insert(k, NetworkAcl::from(v));
12511            }
12512            for (k, v) in view.elastic_ips {
12513                guard.elastic_ips.insert(k, ElasticIp::from(v));
12514            }
12515            for (k, v) in view.nat_gateways {
12516                guard.nat_gateways.insert(k, NatGateway::from(v));
12517            }
12518            for (k, v) in view.dhcp_options {
12519                guard.dhcp_options.insert(k, DhcpOptions::from(v));
12520            }
12521            for (k, v) in view.egress_only_igws {
12522                guard
12523                    .egress_only_igws
12524                    .insert(k, EgressOnlyInternetGateway::from(v));
12525            }
12526            for (k, v) in view.flow_logs {
12527                guard.flow_logs.insert(k, FlowLog::from(v));
12528            }
12529            for (k, v) in view.vpc_peering_connections {
12530                guard
12531                    .vpc_peering_connections
12532                    .insert(k, VpcPeeringConnection::from(v));
12533            }
12534            for (k, v) in view.vpc_endpoints {
12535                guard.vpc_endpoints.insert(k, VpcEndpoint::from(v));
12536            }
12537            for (k, v) in view.managed_prefix_lists {
12538                guard
12539                    .managed_prefix_lists
12540                    .insert(k, ManagedPrefixList::from(v));
12541            }
12542            for (k, v) in view.customer_gateways {
12543                guard.customer_gateways.insert(k, CustomerGateway::from(v));
12544            }
12545            for (k, v) in view.vpn_gateways {
12546                guard.vpn_gateways.insert(k, VpnGateway::from(v));
12547            }
12548            for (k, v) in view.vpn_connections {
12549                guard.vpn_connections.insert(k, VpnConnection::from(v));
12550            }
12551            for (k, v) in view.carrier_gateways {
12552                guard.carrier_gateways.insert(k, CarrierGateway::from(v));
12553            }
12554            for (k, v) in view.network_interfaces {
12555                guard
12556                    .network_interfaces
12557                    .insert(k, NetworkInterface::from(v));
12558            }
12559            for (k, v) in view.vpc_cidr_associations {
12560                guard.vpc_cidr_associations.insert(k, v);
12561            }
12562            if view.ebs_encryption_by_default {
12563                guard.ebs_encryption_by_default = true;
12564            }
12565            for (k, v) in view.transit_gateways {
12566                guard.transit_gateways.insert(k, TransitGateway::from(v));
12567            }
12568            for (k, v) in view.tgw_vpc_attachments {
12569                guard
12570                    .tgw_vpc_attachments
12571                    .insert(k, TransitGatewayVpcAttachment::from(v));
12572            }
12573            for (k, v) in view.tgw_peering_attachments {
12574                guard
12575                    .tgw_peering_attachments
12576                    .insert(k, TransitGatewayPeeringAttachment::from(v));
12577            }
12578            for (k, v) in view.tgw_route_tables {
12579                guard
12580                    .tgw_route_tables
12581                    .insert(k, TransitGatewayRouteTable::from(v));
12582            }
12583            for (k, v) in view.tgw_routes {
12584                guard
12585                    .tgw_routes
12586                    .insert(k, v.into_iter().map(TransitGatewayRoute::from).collect());
12587            }
12588            for (k, v) in view.instances {
12589                guard.instances.insert(k, Instance::from(v));
12590            }
12591            for (k, v) in view.volumes {
12592                guard.volumes.insert(k, Volume::from(v));
12593            }
12594            for (k, v) in view.snapshots {
12595                guard.snapshots.insert(k, Snapshot::from(v));
12596            }
12597            for (k, v) in view.images {
12598                guard.images.insert(k, Image::from(v));
12599            }
12600            for (k, v) in view.launch_templates {
12601                guard.launch_templates.insert(k, LaunchTemplate::from(v));
12602            }
12603            for (k, v) in view.launch_template_versions {
12604                guard
12605                    .launch_template_versions
12606                    .insert(k, v.into_iter().map(LaunchTemplateVersion::from).collect());
12607            }
12608            for (k, v) in view.spot_requests {
12609                guard.spot_requests.insert(k, SpotInstanceRequest::from(v));
12610            }
12611            for (k, v) in view.iam_instance_profile_associations {
12612                guard
12613                    .iam_instance_profile_associations
12614                    .insert(k, IamInstanceProfileAssociation::from(v));
12615            }
12616            for (k, v) in view.dedicated_hosts {
12617                guard.dedicated_hosts.insert(k, DedicatedHost::from(v));
12618            }
12619            for (k, v) in view.ec2_fleets {
12620                guard.ec2_fleets.insert(k, Ec2Fleet::from(v));
12621            }
12622            for (k, v) in view.vpc_endpoint_service_configs {
12623                guard
12624                    .vpc_endpoint_service_configs
12625                    .insert(k, VpcEndpointServiceConfiguration::from(v));
12626            }
12627            for (k, v) in view.spot_fleet_requests {
12628                guard
12629                    .spot_fleet_requests
12630                    .insert(k, SpotFleetRequest::from(v));
12631            }
12632            for (k, v) in view.subnet_cidr_reservations {
12633                guard
12634                    .subnet_cidr_reservations
12635                    .insert(k, SubnetCidrReservationEntry::from(v));
12636            }
12637            for (k, v) in view.placement_groups {
12638                guard.placement_groups.insert(k, PlacementGroup::from(v));
12639            }
12640            for (k, v) in view.network_interface_permissions {
12641                guard
12642                    .network_interface_permissions
12643                    .insert(k, NetworkInterfacePermission::from(v));
12644            }
12645            for (k, v) in view.instance_connect_endpoints {
12646                guard
12647                    .instance_connect_endpoints
12648                    .insert(k, InstanceConnectEndpoint::from(v));
12649            }
12650            for (k, v) in view.capacity_reservations {
12651                guard
12652                    .capacity_reservations
12653                    .insert(k, CapacityReservation::from(v));
12654            }
12655            for (k, v) in view.capacity_reservation_fleets {
12656                guard
12657                    .capacity_reservation_fleets
12658                    .insert(k, CapacityReservationFleet::from(v));
12659            }
12660            for (k, v) in view.coip_pools {
12661                guard.coip_pools.insert(k, CoipPool::from(v));
12662            }
12663            for (k, v) in view.byoip_cidrs {
12664                guard.byoip_cidrs.insert(k, ByoipCidr::from(v));
12665            }
12666            for (k, v) in view.public_ipv4_pools {
12667                guard.public_ipv4_pools.insert(k, PublicIpv4Pool::from(v));
12668            }
12669            for v in view.coip_cidrs {
12670                let key = (v.cidr.clone(), v.coip_pool_id.clone());
12671                guard.coip_cidrs.insert(key, CoipCidr::from(v));
12672            }
12673            for (k, v) in view.address_transfers {
12674                guard.address_transfers.insert(k, AddressTransfer::from(v));
12675            }
12676            for v in view.security_group_vpc_associations {
12677                let key = (v.group_id.clone(), v.vpc_id.clone());
12678                guard
12679                    .security_group_vpc_associations
12680                    .insert(key, SecurityGroupVpcAssociation::from(v));
12681            }
12682            for v in view.enclave_certificate_iam_role_associations {
12683                let key = (v.certificate_arn.clone(), v.role_arn.clone());
12684                guard
12685                    .enclave_certificate_iam_role_associations
12686                    .insert(key, EnclaveCertificateIamRoleAssociation::from(v));
12687            }
12688            for (k, v) in view.mac_sip_modification_tasks {
12689                guard
12690                    .mac_sip_modification_tasks
12691                    .insert(k, MacSipModificationTask::from(v));
12692            }
12693            for (k, v) in view.declarative_policies_reports {
12694                guard
12695                    .declarative_policies_reports
12696                    .insert(k, DeclarativePoliciesReport::from(v));
12697            }
12698            for (k, v) in view.vpn_concentrators {
12699                guard.vpn_concentrators.insert(k, VpnConcentrator::from(v));
12700            }
12701            for v in view.vpc_endpoint_connections {
12702                let key = (v.service_id.clone(), v.vpc_endpoint_id.clone());
12703                guard
12704                    .vpc_endpoint_connections
12705                    .insert(key, VpcEndpointConnection::from(v));
12706            }
12707            for (k, v) in view.vpc_endpoint_connection_notifications {
12708                guard
12709                    .vpc_endpoint_connection_notifications
12710                    .insert(k, VpcEndpointConnectionNotification::from(v));
12711            }
12712            for (k, v) in view.vpc_block_public_access_exclusions {
12713                guard
12714                    .vpc_block_public_access_exclusions
12715                    .insert(k, VpcBlockPublicAccessExclusion::from(v));
12716            }
12717            if let Some(o) = view.vpc_block_public_access_options {
12718                guard.vpc_block_public_access_options = Some(VpcBlockPublicAccessOptions::from(o));
12719            }
12720            for (k, v) in view.vpc_encryption_controls {
12721                guard
12722                    .vpc_encryption_controls
12723                    .insert(k, VpcEncryptionControl::from(v));
12724            }
12725            for (k, v) in view.reserved_instances_exchanges {
12726                guard
12727                    .reserved_instances_exchanges
12728                    .insert(k, crate::types::ReservedInstancesExchange::from(v));
12729            }
12730            for (k, v) in view.reserved_instances_listings {
12731                guard
12732                    .reserved_instances_listings
12733                    .insert(k, crate::types::ReservedInstancesListing::from(v));
12734            }
12735            for (k, v) in view.queued_reserved_instances_purchases {
12736                guard
12737                    .queued_reserved_instances_purchases
12738                    .insert(k, crate::types::ReservedInstancesPurchase::from(v));
12739            }
12740            for (k, v) in view.reserved_instances_modifications {
12741                guard
12742                    .reserved_instances_modifications
12743                    .insert(k, crate::types::ReservedInstancesModification::from(v));
12744            }
12745            for (k, v) in view.reserved_instances_purchases {
12746                guard
12747                    .reserved_instances_purchases
12748                    .insert(k, crate::types::ReservedInstancesPurchase::from(v));
12749            }
12750            for (k, v) in view.reserved_instances {
12751                guard
12752                    .reserved_instances
12753                    .insert(k, crate::types::ReservedInstances::from(v));
12754            }
12755            for (k, v) in view.fpga_images {
12756                guard
12757                    .fpga_images
12758                    .insert(k, crate::types::FpgaImage::from(v));
12759            }
12760            for (k, v) in view.image_usage_reports {
12761                guard
12762                    .image_usage_reports
12763                    .insert(k, crate::types::ImageUsageReport::from(v));
12764            }
12765            for (k, v) in view.restore_image_tasks {
12766                guard
12767                    .restore_image_tasks
12768                    .insert(k, crate::types::RestoreImageTask::from(v));
12769            }
12770            for (k, v) in view.store_image_tasks {
12771                guard
12772                    .store_image_tasks
12773                    .insert(k, crate::types::StoreImageTask::from(v));
12774            }
12775            for (k, v) in view.import_image_tasks {
12776                guard
12777                    .import_image_tasks
12778                    .insert(k, crate::types::ImportImageTask::from(v));
12779            }
12780            if !view.allowed_image_criteria.is_empty() {
12781                guard.allowed_image_criteria = view
12782                    .allowed_image_criteria
12783                    .into_iter()
12784                    .map(crate::types::AllowedImageCriterion::from)
12785                    .collect();
12786            }
12787            for (k, v) in view.default_credit_specifications {
12788                guard.default_credit_specifications.insert(k, v);
12789            }
12790            if let Some(o) = view.instance_metadata_defaults {
12791                guard.instance_metadata_defaults =
12792                    Some(crate::types::InstanceMetadataDefaults::from(o));
12793            }
12794            for (k, v) in view.instance_event_windows {
12795                guard
12796                    .instance_event_windows
12797                    .insert(k, crate::types::InstanceEventWindow::from(v));
12798            }
12799            if let Some(a) = view.instance_event_notification_attributes {
12800                guard.instance_event_notification_attributes =
12801                    Some(crate::types::InstanceTagNotificationAttributes::from(a));
12802            }
12803            for (k, v) in view.instance_events {
12804                guard
12805                    .instance_events
12806                    .insert(k, crate::types::InstanceEvent::from(v));
12807            }
12808            for (k, v) in view.host_reservations {
12809                guard
12810                    .host_reservations
12811                    .insert(k, crate::types::HostReservation::from(v));
12812            }
12813            for (k, v) in view.scheduled_instances {
12814                guard
12815                    .scheduled_instances
12816                    .insert(k, crate::types::ScheduledInstance::from(v));
12817            }
12818            for (k, v) in view.az_group_opt_in {
12819                guard.az_group_opt_in.insert(k, v);
12820            }
12821            guard.instance_status_reports.extend(
12822                view.instance_status_reports
12823                    .into_iter()
12824                    .map(crate::types::InstanceStatusReport::from),
12825            );
12826            for (k, v) in view.network_insights_access_scopes {
12827                guard
12828                    .network_insights_access_scopes
12829                    .insert(k, NetworkInsightsAccessScope::from(v));
12830            }
12831            for (k, v) in view.network_insights_access_scope_analyses {
12832                guard
12833                    .network_insights_access_scope_analyses
12834                    .insert(k, NetworkInsightsAccessScopeAnalysis::from(v));
12835            }
12836            for (k, v) in view.network_insights_paths {
12837                guard
12838                    .network_insights_paths
12839                    .insert(k, NetworkInsightsPath::from(v));
12840            }
12841            for (k, v) in view.network_insights_analyses {
12842                guard
12843                    .network_insights_analyses
12844                    .insert(k, NetworkInsightsAnalysis::from(v));
12845            }
12846            for (k, v) in view.traffic_mirror_filters {
12847                guard
12848                    .traffic_mirror_filters
12849                    .insert(k, TrafficMirrorFilter::from(v));
12850            }
12851            for (k, v) in view.traffic_mirror_sessions {
12852                guard
12853                    .traffic_mirror_sessions
12854                    .insert(k, TrafficMirrorSession::from(v));
12855            }
12856            for (k, v) in view.traffic_mirror_targets {
12857                guard
12858                    .traffic_mirror_targets
12859                    .insert(k, TrafficMirrorTarget::from(v));
12860            }
12861            for (k, v) in view.client_vpn_endpoints {
12862                guard
12863                    .client_vpn_endpoints
12864                    .insert(k, ClientVpnEndpoint::from(v));
12865            }
12866            for (k, v) in view.client_vpn_target_network_associations {
12867                guard
12868                    .client_vpn_target_network_associations
12869                    .insert(k, ClientVpnTargetNetworkAssociation::from(v));
12870            }
12871            for v in view.client_vpn_authorization_rules {
12872                let key = (
12873                    v.client_vpn_endpoint_id.clone(),
12874                    v.destination_cidr.clone(),
12875                    v.group_id.clone().unwrap_or_default(),
12876                );
12877                guard
12878                    .client_vpn_authorization_rules
12879                    .insert(key, ClientVpnAuthorizationRule::from(v));
12880            }
12881            for v in view.client_vpn_routes {
12882                let key = (
12883                    v.client_vpn_endpoint_id.clone(),
12884                    v.destination_cidr.clone(),
12885                    v.target_subnet.clone(),
12886                );
12887                guard.client_vpn_routes.insert(key, ClientVpnRoute::from(v));
12888            }
12889            for (k, v) in view.client_vpn_connections {
12890                guard
12891                    .client_vpn_connections
12892                    .insert(k, ClientVpnConnection::from(v));
12893            }
12894            for (k, v) in view.local_gateways {
12895                guard.local_gateways.insert(k, LocalGateway::from(v));
12896            }
12897            for (k, v) in view.local_gateway_route_tables {
12898                guard
12899                    .local_gateway_route_tables
12900                    .insert(k, LocalGatewayRouteTable::from(v));
12901            }
12902            for v in view.local_gateway_routes {
12903                let key = (
12904                    v.local_gateway_route_table_id.clone(),
12905                    v.destination_cidr_block.clone(),
12906                );
12907                guard
12908                    .local_gateway_routes
12909                    .insert(key, LocalGatewayRoute::from(v));
12910            }
12911            for (k, v) in view.local_gateway_route_table_virtual_interface_group_associations {
12912                guard
12913                    .local_gateway_route_table_virtual_interface_group_associations
12914                    .insert(
12915                        k,
12916                        LocalGatewayRouteTableVirtualInterfaceGroupAssociation::from(v),
12917                    );
12918            }
12919            for (k, v) in view.local_gateway_route_table_vpc_associations {
12920                guard
12921                    .local_gateway_route_table_vpc_associations
12922                    .insert(k, LocalGatewayRouteTableVpcAssociation::from(v));
12923            }
12924            for (k, v) in view.local_gateway_virtual_interfaces {
12925                guard
12926                    .local_gateway_virtual_interfaces
12927                    .insert(k, LocalGatewayVirtualInterface::from(v));
12928            }
12929            for (k, v) in view.local_gateway_virtual_interface_groups {
12930                guard
12931                    .local_gateway_virtual_interface_groups
12932                    .insert(k, LocalGatewayVirtualInterfaceGroup::from(v));
12933            }
12934            for (k, v) in view.route_servers {
12935                guard.route_servers.insert(k, RouteServer::from(v));
12936            }
12937            for (k, v) in view.route_server_endpoints {
12938                guard
12939                    .route_server_endpoints
12940                    .insert(k, RouteServerEndpoint::from(v));
12941            }
12942            for (k, v) in view.route_server_peers {
12943                guard.route_server_peers.insert(k, RouteServerPeer::from(v));
12944            }
12945            for v in view.route_server_associations {
12946                let key = (v.route_server_id.clone(), v.vpc_id.clone());
12947                guard
12948                    .route_server_associations
12949                    .insert(key, RouteServerAssociation::from(v));
12950            }
12951            for (k, v) in view.verified_access_instances {
12952                guard
12953                    .verified_access_instances
12954                    .insert(k, VerifiedAccessInstance::from(v));
12955            }
12956            for (k, v) in view.verified_access_trust_providers {
12957                guard
12958                    .verified_access_trust_providers
12959                    .insert(k, VerifiedAccessTrustProvider::from(v));
12960            }
12961            for (k, v) in view.verified_access_groups {
12962                guard
12963                    .verified_access_groups
12964                    .insert(k, VerifiedAccessGroup::from(v));
12965            }
12966            for (k, v) in view.verified_access_endpoints {
12967                guard
12968                    .verified_access_endpoints
12969                    .insert(k, VerifiedAccessEndpoint::from(v));
12970            }
12971            for v in view.verified_access_trust_provider_attachments {
12972                let key = (v.instance_id.clone(), v.trust_provider_id.clone());
12973                guard
12974                    .verified_access_trust_provider_attachments
12975                    .insert(key, VerifiedAccessTrustProviderAttachment::from(v));
12976            }
12977            for (k, v) in view.verified_access_instance_logging_configurations {
12978                guard
12979                    .verified_access_instance_logging_configurations
12980                    .insert(k, VerifiedAccessLogs::from(v));
12981            }
12982            for o in view.billing_ownership_offers {
12983                let key = (
12984                    o.capacity_reservation_id.clone(),
12985                    o.unused_reservation_billing_owner_id.clone(),
12986                );
12987                guard
12988                    .billing_ownership_offers
12989                    .insert(key, BillingOwnershipOffer::from(o));
12990            }
12991            for (k, v) in view.capacity_manager_data_exports {
12992                guard
12993                    .capacity_manager_data_exports
12994                    .insert(k, CapacityManagerDataExport::from(v));
12995            }
12996            for (k, v) in view.interruptible_capacity_reservation_allocations {
12997                guard
12998                    .interruptible_capacity_reservation_allocations
12999                    .insert(k, InterruptibleCapacityReservationAllocation::from(v));
13000            }
13001            for (k, v) in view.capacity_blocks {
13002                guard.capacity_blocks.insert(k, CapacityBlock::from(v));
13003            }
13004            for (k, v) in view.capacity_block_extensions {
13005                guard
13006                    .capacity_block_extensions
13007                    .insert(k, CapacityBlockExtension::from(v));
13008            }
13009            if let Some(a) = view.capacity_manager_organizations_access {
13010                guard.capacity_manager_organizations_access =
13011                    Some(CapacityManagerOrganizationsAccess::from(a));
13012            }
13013            for (k, v) in view.tgw_multicast_domains {
13014                guard
13015                    .tgw_multicast_domains
13016                    .insert(k, TransitGatewayMulticastDomain::from(v));
13017            }
13018            for v in view.tgw_multicast_domain_associations {
13019                let key = (
13020                    v.transit_gateway_multicast_domain_id.clone(),
13021                    v.transit_gateway_attachment_id.clone(),
13022                );
13023                guard
13024                    .tgw_multicast_domain_associations
13025                    .insert(key, TransitGatewayMulticastDomainAssociation::from(v));
13026            }
13027            for v in view.tgw_multicast_group_members {
13028                let key = (
13029                    v.transit_gateway_multicast_domain_id.clone(),
13030                    v.group_ip_address.clone(),
13031                    v.network_interface_id.clone(),
13032                );
13033                guard
13034                    .tgw_multicast_group_members
13035                    .insert(key, TransitGatewayMulticastGroupMember::from(v));
13036            }
13037            for v in view.tgw_multicast_group_sources {
13038                let key = (
13039                    v.transit_gateway_multicast_domain_id.clone(),
13040                    v.group_ip_address.clone(),
13041                    v.network_interface_id.clone(),
13042                );
13043                guard
13044                    .tgw_multicast_group_sources
13045                    .insert(key, TransitGatewayMulticastGroupSource::from(v));
13046            }
13047            for (k, v) in view.tgw_connects {
13048                guard.tgw_connects.insert(k, TransitGatewayConnect::from(v));
13049            }
13050            for (k, v) in view.tgw_connect_peers {
13051                guard
13052                    .tgw_connect_peers
13053                    .insert(k, TransitGatewayConnectPeer::from(v));
13054            }
13055            for (k, v) in view.tgw_metering_policies {
13056                guard
13057                    .tgw_metering_policies
13058                    .insert(k, TransitGatewayMeteringPolicy::from(v));
13059            }
13060            for v in view.tgw_metering_policy_entries {
13061                let key = (
13062                    v.transit_gateway_metering_policy_id.clone(),
13063                    v.transit_gateway_metering_policy_entry_id.clone(),
13064                );
13065                guard
13066                    .tgw_metering_policy_entries
13067                    .insert(key, TransitGatewayMeteringPolicyEntry::from(v));
13068            }
13069            for (k, v) in view.tgw_policy_tables {
13070                guard
13071                    .tgw_policy_tables
13072                    .insert(k, TransitGatewayPolicyTable::from(v));
13073            }
13074            for v in view.tgw_policy_table_associations {
13075                let key = (
13076                    v.transit_gateway_policy_table_id.clone(),
13077                    v.transit_gateway_attachment_id.clone(),
13078                );
13079                guard
13080                    .tgw_policy_table_associations
13081                    .insert(key, TransitGatewayPolicyTableAssociation::from(v));
13082            }
13083            for v in view.tgw_prefix_list_references {
13084                let key = (
13085                    v.transit_gateway_route_table_id.clone(),
13086                    v.prefix_list_id.clone(),
13087                );
13088                guard
13089                    .tgw_prefix_list_references
13090                    .insert(key, TransitGatewayPrefixListReference::from(v));
13091            }
13092            for (k, v) in view.tgw_route_table_announcements {
13093                guard
13094                    .tgw_route_table_announcements
13095                    .insert(k, TransitGatewayRouteTableAnnouncement::from(v));
13096            }
13097            for (k, v) in view.ipams {
13098                guard.ipams.insert(k, Ipam::from(v));
13099            }
13100            for (k, v) in view.ipam_scopes {
13101                guard.ipam_scopes.insert(k, IpamScope::from(v));
13102            }
13103            for (k, v) in view.ipam_pools {
13104                guard.ipam_pools.insert(k, IpamPool::from(v));
13105            }
13106            for v in view.ipam_pool_cidrs {
13107                let key = (v.ipam_pool_id.clone(), v.cidr.clone());
13108                guard.ipam_pool_cidrs.insert(key, IpamPoolCidr::from(v));
13109            }
13110            for v in view.ipam_pool_allocations {
13111                let key = (v.ipam_pool_id.clone(), v.ipam_pool_allocation_id.clone());
13112                guard
13113                    .ipam_pool_allocations
13114                    .insert(key, IpamPoolAllocation::from(v));
13115            }
13116            for (k, v) in view.ipam_resource_discoveries {
13117                guard
13118                    .ipam_resource_discoveries
13119                    .insert(k, IpamResourceDiscovery::from(v));
13120            }
13121            for (k, v) in view.ipam_resource_discovery_associations {
13122                guard
13123                    .ipam_resource_discovery_associations
13124                    .insert(k, IpamResourceDiscoveryAssociation::from(v));
13125            }
13126            for v in view.ipam_byoasns {
13127                let key = (v.ipam_id.clone(), v.asn.clone());
13128                guard.ipam_byoasns.insert(key, IpamByoasn::from(v));
13129            }
13130            for (k, v) in view.ipam_external_resource_verification_tokens {
13131                guard
13132                    .ipam_external_resource_verification_tokens
13133                    .insert(k, IpamExternalResourceVerificationToken::from(v));
13134            }
13135            for (k, v) in view.ipam_policies {
13136                guard.ipam_policies.insert(k, IpamPolicy::from(v));
13137            }
13138            for (k, v) in view.ipam_prefix_list_resolvers {
13139                guard
13140                    .ipam_prefix_list_resolvers
13141                    .insert(k, IpamPrefixListResolver::from(v));
13142            }
13143            for v in view.ipam_prefix_list_resolver_targets {
13144                let key = (
13145                    v.ipam_prefix_list_resolver_id.clone(),
13146                    v.ipam_prefix_list_resolver_target_id.clone(),
13147                );
13148                guard
13149                    .ipam_prefix_list_resolver_targets
13150                    .insert(key, IpamPrefixListResolverTarget::from(v));
13151            }
13152            for (k, v) in view.volume_modifications {
13153                guard
13154                    .volume_modifications
13155                    .insert(k, crate::types::VolumeModification::from(v));
13156            }
13157            for (k, v) in view.import_volume_tasks {
13158                guard
13159                    .import_volume_tasks
13160                    .insert(k, crate::types::ImportVolumeTask::from(v));
13161            }
13162            for (k, v) in view.bundle_tasks {
13163                guard
13164                    .bundle_tasks
13165                    .insert(k, crate::types::BundleTask::from(v));
13166            }
13167            for (k, v) in view.id_format {
13168                guard
13169                    .id_format
13170                    .insert(k, crate::types::IdFormatEntry::from(v));
13171            }
13172            for (k, v) in view.outpost_lags {
13173                guard
13174                    .outpost_lags
13175                    .insert(k, crate::types::OutpostLag::from(v));
13176            }
13177            for (k, v) in view.export_image_tasks {
13178                guard
13179                    .export_image_tasks
13180                    .insert(k, crate::types::ExportImageTask::from(v));
13181            }
13182            // Wave 4 additions: only overwrite when the incoming view supplies
13183            // a non-default value. This keeps `merge` additive: an empty incoming
13184            // view does not clear existing toggles.
13185            if view.ebs_default_kms_key_id.is_some() {
13186                guard.ebs_default_kms_key_id = view.ebs_default_kms_key_id;
13187            }
13188            if view.serial_console_access_enabled {
13189                guard.serial_console_access_enabled = true;
13190            }
13191            if view.allowed_images_settings_state.is_some() {
13192                guard.allowed_images_settings_state = view.allowed_images_settings_state;
13193            }
13194            if view.image_block_public_access_state.is_some() {
13195                guard.image_block_public_access_state = view.image_block_public_access_state;
13196            }
13197            for s in view.aws_network_performance_subscriptions {
13198                let key = (
13199                    s.source.clone(),
13200                    s.destination.clone(),
13201                    s.metric.clone(),
13202                    s.statistic.clone(),
13203                );
13204                guard.aws_network_performance_subscriptions.insert(
13205                    key,
13206                    crate::types::AwsNetworkPerformanceSubscription {
13207                        source: s.source,
13208                        destination: s.destination,
13209                        metric: s.metric,
13210                        statistic: s.statistic,
13211                        period: s.period,
13212                    },
13213                );
13214            }
13215        }
13216        self.notify_state_changed(account_id, region).await;
13217        Ok(())
13218    }
13219
13220    fn notifier(&self) -> &StateChangeNotifier<Self::StateView> {
13221        &self.notifier
13222    }
13223}