aws

Documentation

Overview

Copyright 2017 WALLIX

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

• Variables
• func Mocks() []*mockDef

Variables

var DriversDefs = []driversDef{
	{
		Api: "ec2",
		Drivers: []driver{

			{
				Action: "create", Entity: cloud.Vpc, Input: "CreateVpcInput", Output: "CreateVpcOutput", ApiMethod: "CreateVpc", OutputExtractor: "aws.StringValue(output.Vpc.VpcId)",
				RequiredParams: []param{
					{AwsField: "CidrBlock", TemplateName: "cidr", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Name", TemplateName: "name", AsAwsTag: true},
				},
			},
			{
				Action: "delete", Entity: cloud.Vpc, Input: "DeleteVpcInput", Output: "DeleteVpcOutput", ApiMethod: "DeleteVpc",
				RequiredParams: []param{
					{AwsField: "VpcId", TemplateName: "id", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.Subnet, Input: "CreateSubnetInput", Output: "CreateSubnetOutput", ApiMethod: "CreateSubnet", OutputExtractor: "aws.StringValue(output.Subnet.SubnetId)",
				RequiredParams: []param{
					{AwsField: "CidrBlock", TemplateName: "cidr", AwsType: "awsstr"},
					{AwsField: "VpcId", TemplateName: "vpc", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "AvailabilityZone", TemplateName: "availabilityzone", AwsType: "awsstr"},
					{AwsField: "Name", TemplateName: "name", AsAwsTag: true},
				},
			},
			{
				Action: "update", Entity: cloud.Subnet, Input: "ModifySubnetAttributeInput", Output: "ModifySubnetAttributeOutput", ApiMethod: "ModifySubnetAttribute", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "SubnetId", TemplateName: "id", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "MapPublicIpOnLaunch", TemplateName: "public", AwsType: "awsboolattribute"},
				},
			},
			{
				Action: "delete", Entity: cloud.Subnet, Input: "DeleteSubnetInput", Output: "DeleteSubnetOutput", ApiMethod: "DeleteSubnet",
				RequiredParams: []param{
					{AwsField: "SubnetId", TemplateName: "id", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.Instance, Input: "RunInstancesInput", Output: "Reservation", ApiMethod: "RunInstances", OutputExtractor: "aws.StringValue(output.Instances[0].InstanceId)",
				RequiredParams: []param{
					{AwsField: "ImageId", TemplateName: "image", AwsType: "awsstr"},
					{AwsField: "MaxCount", TemplateName: "count", AwsType: "awsint64"},
					{AwsField: "MinCount", TemplateName: "count", AwsType: "awsint64"},
					{AwsField: "InstanceType", TemplateName: "type", AwsType: "awsstr"},
					{AwsField: "SubnetId", TemplateName: "subnet", AwsType: "awsstr"},
					{AwsField: "Name", TemplateName: "name", AsAwsTag: true},
				},
				ExtraParams: []param{
					{AwsField: "KeyName", TemplateName: "keypair", AwsType: "awsstr"},
					{AwsField: "PrivateIpAddress", TemplateName: "ip", AwsType: "awsstr"},
					{AwsField: "UserData", TemplateName: "userdata", AwsType: "awsfiletobase64"},
					{AwsField: "SecurityGroupIds", TemplateName: "securitygroup", AwsType: "awsstringslice"},
					{AwsField: "DisableApiTermination", TemplateName: "lock", AwsType: "awsboolattribute"},
					{AwsField: "IamInstanceProfile.Name", TemplateName: "role", AwsType: "awsstr"},
				},
			},
			{
				Action: "update", Entity: cloud.Instance, Input: "ModifyInstanceAttributeInput", Output: "ModifyInstanceAttributeOutput", ApiMethod: "ModifyInstanceAttribute",
				RequiredParams: []param{
					{AwsField: "InstanceId", TemplateName: "id", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "InstanceType", TemplateName: "type", AwsType: "awsstr"},
					{AwsField: "DisableApiTermination", TemplateName: "lock", AwsType: "awsboolattribute"},
				},
			},
			{
				Action: "delete", Entity: cloud.Instance, Input: "TerminateInstancesInput", Output: "TerminateInstancesOutput", ApiMethod: "TerminateInstances",
				RequiredParams: []param{
					{AwsField: "InstanceIds", TemplateName: "id", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "start", Entity: cloud.Instance, Input: "StartInstancesInput", Output: "StartInstancesOutput", ApiMethod: "StartInstances", OutputExtractor: "aws.StringValue(output.StartingInstances[0].InstanceId)",
				RequiredParams: []param{
					{AwsField: "InstanceIds", TemplateName: "id", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "stop", Entity: cloud.Instance, Input: "StopInstancesInput", Output: "StopInstancesOutput", ApiMethod: "StopInstances", OutputExtractor: "aws.StringValue(output.StoppingInstances[0].InstanceId)",
				RequiredParams: []param{
					{AwsField: "InstanceIds", TemplateName: "id", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "check", Entity: cloud.Instance, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
					{TemplateName: "state"},
					{TemplateName: "timeout"},
				},
			},

			{
				Action: "create", Entity: cloud.SecurityGroup, Input: "CreateSecurityGroupInput", Output: "CreateSecurityGroupOutput", ApiMethod: "CreateSecurityGroup", OutputExtractor: "aws.StringValue(output.GroupId)",
				RequiredParams: []param{
					{AwsField: "GroupName", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "VpcId", TemplateName: "vpc", AwsType: "awsstr"},
					{AwsField: "Description", TemplateName: "description", AwsType: "awsstr"},
				},
			},
			{
				Action: "update", Entity: cloud.SecurityGroup, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
					{TemplateName: "cidr"},
					{TemplateName: "protocol"},
				},
				ExtraParams: []param{
					{TemplateName: "inbound"},
					{TemplateName: "outbound"},
					{TemplateName: "portrange"},
				},
			},
			{
				Action: "delete", Entity: cloud.SecurityGroup, Input: "DeleteSecurityGroupInput", Output: "DeleteSecurityGroupOutput", ApiMethod: "DeleteSecurityGroup",
				RequiredParams: []param{
					{AwsField: "GroupId", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "check", Entity: cloud.SecurityGroup, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
					{TemplateName: "state"},
					{TemplateName: "timeout"},
				},
			},
			{
				Action: "attach", Entity: cloud.SecurityGroup, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
				},
				ExtraParams: []param{
					{TemplateName: "instance"},
				},
			},
			{
				Action: "detach", Entity: cloud.SecurityGroup, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
				},
				ExtraParams: []param{
					{TemplateName: "instance"},
				},
			},

			{
				Action: "copy", Entity: cloud.Image, Input: "CopyImageInput", Output: "CopyImageOutput", ApiMethod: "CopyImage", OutputExtractor: "aws.StringValue(output.ImageId)",
				RequiredParams: []param{
					{AwsField: "Name", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "SourceImageId", TemplateName: "source-id", AwsType: "awsstr"},
					{AwsField: "SourceRegion", TemplateName: "source-region", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Encrypted", TemplateName: "encrypted", AwsType: "awsbool"},
					{AwsField: "Description", TemplateName: "description", AwsType: "awsstr"},
				},
			},
			{
				Action: "import", Entity: cloud.Image, ApiMethod: "ImportImage", Input: "ImportImageInput", Output: "ImportImageOutput", OutputExtractor: "aws.StringValue(output.ImportTaskId)",
				RequiredParams: []param{},
				ExtraParams: []param{
					{AwsField: "Architecture", TemplateName: "architecture", AwsType: "awsstr"},
					{AwsField: "Description", TemplateName: "description", AwsType: "awsstr"},
					{AwsField: "LicenseType", TemplateName: "license", AwsType: "awsstr"},
					{AwsField: "Platform", TemplateName: "platform", AwsType: "awsstr"},
					{AwsField: "RoleName", TemplateName: "role", AwsType: "awsstr"},
					{AwsField: "DiskContainers[0]SnapshotId", TemplateName: "snapshot", AwsType: "awsslicestruct"},
					{AwsField: "DiskContainers[0]Url", TemplateName: "url", AwsType: "awsslicestruct"},
					{AwsField: "DiskContainers[0]UserBucket.S3Bucket", TemplateName: "bucket", AwsType: "awsslicestruct"},
					{AwsField: "DiskContainers[0]UserBucket.S3Key", TemplateName: "s3object", AwsType: "awsslicestruct"},
				},
			},
			{
				Action: "delete", Entity: cloud.Image, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
					{TemplateName: "delete-snapshots"},
				},
			},

			{
				Action: "create", Entity: cloud.Volume, Input: "CreateVolumeInput", Output: "Volume", ApiMethod: "CreateVolume", OutputExtractor: "aws.StringValue(output.VolumeId)",
				RequiredParams: []param{
					{AwsField: "AvailabilityZone", TemplateName: "availabilityzone", AwsType: "awsstr"},
					{AwsField: "Size", TemplateName: "size", AwsType: "awsint64"},
				},
			},
			{
				Action: "delete", Entity: cloud.Volume, Input: "DeleteVolumeInput", Output: "DeleteVolumeOutput", ApiMethod: "DeleteVolume",
				RequiredParams: []param{
					{AwsField: "VolumeId", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.Volume, Input: "AttachVolumeInput", Output: "VolumeAttachment", ApiMethod: "AttachVolume", OutputExtractor: "aws.StringValue(output.VolumeId)",
				RequiredParams: []param{
					{AwsField: "Device", TemplateName: "device", AwsType: "awsstr"},
					{AwsField: "VolumeId", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "InstanceId", TemplateName: "instance", AwsType: "awsstr"},
				},
			},
			{
				Action: "detach", Entity: cloud.Volume, Input: "DetachVolumeInput", Output: "VolumeAttachment", ApiMethod: "DetachVolume", OutputExtractor: "aws.StringValue(output.VolumeId)",
				RequiredParams: []param{
					{AwsField: "Device", TemplateName: "device", AwsType: "awsstr"},
					{AwsField: "VolumeId", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "InstanceId", TemplateName: "instance", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Force", TemplateName: "force", AwsType: "awsbool"},
				},
			},

			{
				Action: "create", Entity: cloud.Snapshot, ApiMethod: "CreateSnapshot", Input: "CreateSnapshotInput", Output: "Snapshot", OutputExtractor: "aws.StringValue(output.SnapshotId)",
				RequiredParams: []param{
					{AwsField: "VolumeId", TemplateName: "volume", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Description", TemplateName: "description", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.Snapshot, ApiMethod: "DeleteSnapshot", Input: "DeleteSnapshotInput", Output: "DeleteSnapshotOutput",
				RequiredParams: []param{
					{AwsField: "SnapshotId", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "copy", Entity: cloud.Snapshot, ApiMethod: "CopySnapshot", Input: "CopySnapshotInput", Output: "CopySnapshotOutput", OutputExtractor: "aws.StringValue(output.SnapshotId)",
				RequiredParams: []param{
					{AwsField: "SourceSnapshotId", TemplateName: "source-id", AwsType: "awsstr"},
					{AwsField: "SourceRegion", TemplateName: "source-region", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Encrypted", TemplateName: "encrypted", AwsType: "awsbool"},
					{AwsField: "Description", TemplateName: "description", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.InternetGateway, Input: "CreateInternetGatewayInput", Output: "CreateInternetGatewayOutput", ApiMethod: "CreateInternetGateway", OutputExtractor: "aws.StringValue(output.InternetGateway.InternetGatewayId)",
			},
			{
				Action: "delete", Entity: cloud.InternetGateway, Input: "DeleteInternetGatewayInput", Output: "DeleteInternetGatewayOutput", ApiMethod: "DeleteInternetGateway",
				RequiredParams: []param{
					{AwsField: "InternetGatewayId", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.InternetGateway, Input: "AttachInternetGatewayInput", Output: "AttachInternetGatewayOutput", ApiMethod: "AttachInternetGateway",
				RequiredParams: []param{
					{AwsField: "InternetGatewayId", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "VpcId", TemplateName: "vpc", AwsType: "awsstr"},
				},
			},
			{
				Action: "detach", Entity: cloud.InternetGateway, Input: "DetachInternetGatewayInput", Output: "DetachInternetGatewayOutput", ApiMethod: "DetachInternetGateway",
				RequiredParams: []param{
					{AwsField: "InternetGatewayId", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "VpcId", TemplateName: "vpc", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.RouteTable, Input: "CreateRouteTableInput", Output: "CreateRouteTableOutput", ApiMethod: "CreateRouteTable", OutputExtractor: "aws.StringValue(output.RouteTable.RouteTableId)",
				RequiredParams: []param{
					{AwsField: "VpcId", TemplateName: "vpc", AwsType: "awsstr"}},
			},
			{
				Action: "delete", Entity: cloud.RouteTable, Input: "DeleteRouteTableInput", Output: "DeleteRouteTableOutput", ApiMethod: "DeleteRouteTable",
				RequiredParams: []param{
					{AwsField: "RouteTableId", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.RouteTable, Input: "AssociateRouteTableInput", Output: "AssociateRouteTableOutput", ApiMethod: "AssociateRouteTable", OutputExtractor: "aws.StringValue(output.AssociationId)",
				RequiredParams: []param{
					{AwsField: "RouteTableId", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "SubnetId", TemplateName: "subnet", AwsType: "awsstr"},
				},
			},
			{
				Action: "detach", Entity: cloud.RouteTable, Input: "DisassociateRouteTableInput", Output: "DisassociateRouteTableOutput", ApiMethod: "DisassociateRouteTable",
				RequiredParams: []param{
					{AwsField: "AssociationId", TemplateName: "association", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: "route", Input: "CreateRouteInput", Output: "CreateRouteOutput", ApiMethod: "CreateRoute",
				RequiredParams: []param{
					{AwsField: "RouteTableId", TemplateName: "table", AwsType: "awsstr"},
					{AwsField: "DestinationCidrBlock", TemplateName: "cidr", AwsType: "awsstr"},
					{AwsField: "GatewayId", TemplateName: "gateway", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: "route", Input: "DeleteRouteInput", Output: "DeleteRouteOutput", ApiMethod: "DeleteRoute",
				RequiredParams: []param{
					{AwsField: "RouteTableId", TemplateName: "table", AwsType: "awsstr"},
					{AwsField: "DestinationCidrBlock", TemplateName: "cidr", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: "tag", ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "resource"},
					{TemplateName: "key"},
					{TemplateName: "value"},
				},
			},
			{
				Action: "delete", Entity: "tag", ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "resource"},
					{TemplateName: "key"},
					{TemplateName: "value"},
				},
			},

			{
				Action: "create", Entity: cloud.Keypair, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "name"},
				},
				ExtraParams: []param{
					{TemplateName: "encrypted"},
				},
			},
			{
				Action: "delete", Entity: cloud.Keypair, Input: "DeleteKeyPairInput", Output: "DeleteKeyPairOutput", ApiMethod: "DeleteKeyPair",
				RequiredParams: []param{
					{AwsField: "KeyName", TemplateName: "id", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.ElasticIP, ApiMethod: "AllocateAddress", Input: "AllocateAddressInput", Output: "AllocateAddressOutput", OutputExtractor: "aws.StringValue(output.AllocationId)",
				RequiredParams: []param{
					{AwsField: "Domain", TemplateName: "domain", AwsType: "awsstr"},
				},
				ExtraParams: []param{},
			},
			{
				Action: "delete", Entity: cloud.ElasticIP, ApiMethod: "ReleaseAddress", Input: "ReleaseAddressInput", Output: "ReleaseAddressOutput",
				ExtraParams: []param{
					{AwsField: "AllocationId", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "PublicIp", TemplateName: "ip", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.ElasticIP, ApiMethod: "AssociateAddress", Input: "AssociateAddressInput", Output: "AssociateAddressOutput", OutputExtractor: "aws.StringValue(output.AssociationId)",
				RequiredParams: []param{
					{AwsField: "AllocationId", TemplateName: "id", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "InstanceId", TemplateName: "instance", AwsType: "awsstr"},
					{AwsField: "NetworkInterfaceId", TemplateName: "networkinterface", AwsType: "awsstr"},
					{AwsField: "PrivateIpAddress", TemplateName: "privateip", AwsType: "awsstr"},
					{AwsField: "AllowReassociation", TemplateName: "allow-reassociation", AwsType: "awsbool"},
				},
			},
			{
				Action: "detach", Entity: cloud.ElasticIP, ApiMethod: "DisassociateAddress", Input: "DisassociateAddressInput", Output: "DisassociateAddressOutput",
				RequiredParams: []param{
					{AwsField: "AssociationId", TemplateName: "association", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api: "elbv2",
		Drivers: []driver{

			{
				Action: "create", Entity: cloud.LoadBalancer, Input: "CreateLoadBalancerInput", Output: "CreateLoadBalancerOutput", ApiMethod: "CreateLoadBalancer", DryRunUnsupported: true, OutputExtractor: "aws.StringValue(output.LoadBalancers[0].LoadBalancerArn)",
				RequiredParams: []param{
					{AwsField: "Name", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "Subnets", TemplateName: "subnets", AwsType: "awsstringslice"},
				},
				ExtraParams: []param{
					{AwsField: "IpAddressType", TemplateName: "iptype", AwsType: "awsstr"},
					{AwsField: "Scheme", TemplateName: "scheme", AwsType: "awsstr"},
					{AwsField: "SecurityGroups", TemplateName: "securitygroups", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "delete", Entity: cloud.LoadBalancer, Input: "DeleteLoadBalancerInput", Output: "DeleteLoadBalancerOutput", ApiMethod: "DeleteLoadBalancer", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "LoadBalancerArn", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "check", Entity: cloud.LoadBalancer, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
					{TemplateName: "state"},
					{TemplateName: "timeout"},
				},
			},

			{
				Action: "create", Entity: cloud.Listener, Input: "CreateListenerInput", Output: "CreateListenerOutput", ApiMethod: "CreateListener", DryRunUnsupported: true, OutputExtractor: "aws.StringValue(output.Listeners[0].ListenerArn)",
				RequiredParams: []param{
					{AwsField: "DefaultActions[0]Type", TemplateName: "actiontype", AwsType: "awsslicestruct"},
					{AwsField: "DefaultActions[0]TargetGroupArn", TemplateName: "target", AwsType: "awsslicestruct"},
					{AwsField: "LoadBalancerArn", TemplateName: "loadbalancer", AwsType: "awsstr"},
					{AwsField: "Port", TemplateName: "port", AwsType: "awsint64"},
					{AwsField: "Protocol", TemplateName: "protocol", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Certificates[0]CertificateArn", TemplateName: "certificate", AwsType: "awsslicestruct"},
					{AwsField: "SslPolicy", TemplateName: "sslpolicy", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.Listener, Input: "DeleteListenerInput", Output: "DeleteListenerOutput", ApiMethod: "DeleteListener", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "ListenerArn", TemplateName: "id", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.TargetGroup, Input: "CreateTargetGroupInput", Output: "CreateTargetGroupOutput", ApiMethod: "CreateTargetGroup", DryRunUnsupported: true, OutputExtractor: "aws.StringValue(output.TargetGroups[0].TargetGroupArn)",
				RequiredParams: []param{
					{AwsField: "Name", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "Port", TemplateName: "port", AwsType: "awsint64"},
					{AwsField: "Protocol", TemplateName: "protocol", AwsType: "awsstr"},
					{AwsField: "VpcId", TemplateName: "vpc", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "HealthCheckIntervalSeconds", TemplateName: "healthcheckinterval", AwsType: "awsint64"},
					{AwsField: "HealthCheckPath", TemplateName: "healthcheckpath", AwsType: "awsstr"},
					{AwsField: "HealthCheckPort", TemplateName: "healthcheckport", AwsType: "awsstr"},
					{AwsField: "HealthCheckProtocol", TemplateName: "healthcheckprotocol", AwsType: "awsstr"},
					{AwsField: "HealthCheckTimeoutSeconds", TemplateName: "healthchecktimeout", AwsType: "awsint64"},
					{AwsField: "HealthyThresholdCount", TemplateName: "healthythreshold", AwsType: "awsint64"},
					{AwsField: "UnhealthyThresholdCount", TemplateName: "unhealthythreshold", AwsType: "awsint64"},
					{AwsField: "Matcher.HttpCode", TemplateName: "matcher", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.TargetGroup, Input: "DeleteTargetGroupInput", Output: "DeleteTargetGroupOutput", ApiMethod: "DeleteTargetGroup", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "TargetGroupArn", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.Instance, ApiMethod: "RegisterTargets", Input: "RegisterTargetsInput", Output: "RegisterTargetsOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "TargetGroupArn", TemplateName: "targetgroup", AwsType: "awsstr"},
					{AwsField: "Targets[0]Id", TemplateName: "id", AwsType: "awsslicestruct"},
				},
				ExtraParams: []param{
					{AwsField: "Targets[0]Port", TemplateName: "port", AwsType: "awsslicestruct"},
				},
			},
			{
				Action: "detach", Entity: cloud.Instance, ApiMethod: "DeregisterTargets", Input: "DeregisterTargetsInput", Output: "DeregisterTargetsOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "TargetGroupArn", TemplateName: "targetgroup", AwsType: "awsstr"},
					{AwsField: "Targets[0]Id", TemplateName: "id", AwsType: "awsslicestruct"},
				},
			},
		},
	},
	{
		Api:          "autoscaling",
		ApiInterface: "AutoScalingAPI",
		Drivers: []driver{
			{
				Action: "create", Entity: cloud.LaunchConfiguration, ApiMethod: "CreateLaunchConfiguration", Input: "CreateLaunchConfigurationInput", Output: "CreateLaunchConfigurationOutput", DryRunUnsupported: true, OutputExtractor: "params[\"name\"]",
				RequiredParams: []param{
					{AwsField: "ImageId", TemplateName: "image", AwsType: "awsstr"},
					{AwsField: "InstanceType", TemplateName: "type", AwsType: "awsstr"},
					{AwsField: "LaunchConfigurationName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "AssociatePublicIpAddress", TemplateName: "public", AwsType: "awsbool"},
					{AwsField: "KeyName", TemplateName: "keypair", AwsType: "awsstr"},
					{AwsField: "UserData", TemplateName: "userdata", AwsType: "awsfiletobase64"},
					{AwsField: "SecurityGroups", TemplateName: "securitygroups", AwsType: "awsstringslice"},
					{AwsField: "IamInstanceProfile", TemplateName: "role", AwsType: "awsstr"},
					{AwsField: "SpotPrice", TemplateName: "spotprice", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.LaunchConfiguration, ApiMethod: "DeleteLaunchConfiguration", Input: "DeleteLaunchConfigurationInput", Output: "DeleteLaunchConfigurationOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "LaunchConfigurationName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "create", Entity: cloud.ScalingGroup, ApiMethod: "CreateAutoScalingGroup", Input: "CreateAutoScalingGroupInput", Output: "CreateAutoScalingGroupOutput", DryRunUnsupported: true, OutputExtractor: "params[\"name\"]",
				RequiredParams: []param{
					{AwsField: "AutoScalingGroupName", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "LaunchConfigurationName", TemplateName: "launchconfiguration", AwsType: "awsstr"},
					{AwsField: "MaxSize", TemplateName: "max-size", AwsType: "awsint64"},
					{AwsField: "MinSize", TemplateName: "min-size", AwsType: "awsint64"},
					{AwsField: "VPCZoneIdentifier", TemplateName: "subnets", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "DefaultCooldown", TemplateName: "cooldown", AwsType: "awsint64"},
					{AwsField: "DesiredCapacity", TemplateName: "desired-capacity", AwsType: "awsint64"},
					{AwsField: "HealthCheckGracePeriod", TemplateName: "healthcheck-grace-period", AwsType: "awsint64"},
					{AwsField: "HealthCheckType", TemplateName: "healthcheck-type", AwsType: "awsstr"},
					{AwsField: "NewInstancesProtectedFromScaleIn", TemplateName: "new-instances-protected", AwsType: "awsbool"},
					{AwsField: "TargetGroupARNs", TemplateName: "targetgroups", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "update", Entity: cloud.ScalingGroup, ApiMethod: "UpdateAutoScalingGroup", Input: "UpdateAutoScalingGroupInput", Output: "UpdateAutoScalingGroupOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "AutoScalingGroupName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "DefaultCooldown", TemplateName: "cooldown", AwsType: "awsint64"},
					{AwsField: "DesiredCapacity", TemplateName: "desired-capacity", AwsType: "awsint64"},
					{AwsField: "HealthCheckGracePeriod", TemplateName: "healthcheck-grace-period", AwsType: "awsint64"},
					{AwsField: "HealthCheckType", TemplateName: "healthcheck-type", AwsType: "awsstr"},
					{AwsField: "LaunchConfigurationName", TemplateName: "launchconfiguration", AwsType: "awsstr"},
					{AwsField: "MaxSize", TemplateName: "max-size", AwsType: "awsint64"},
					{AwsField: "MinSize", TemplateName: "min-size", AwsType: "awsint64"},
					{AwsField: "NewInstancesProtectedFromScaleIn", TemplateName: "new-instances-protected", AwsType: "awsbool"},
					{AwsField: "VPCZoneIdentifier", TemplateName: "subnets", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.ScalingGroup, ApiMethod: "DeleteAutoScalingGroup", Input: "DeleteAutoScalingGroupInput", Output: "DeleteAutoScalingGroupOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "AutoScalingGroupName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "ForceDelete", TemplateName: "force", AwsType: "awsbool"},
				},
			},
			{
				Action: "check", Entity: cloud.ScalingGroup, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "name"},
					{TemplateName: "count"},
					{TemplateName: "timeout"},
				},
			},
			{
				Action: "create", Entity: cloud.ScalingPolicy, ApiMethod: "PutScalingPolicy", Input: "PutScalingPolicyInput", Output: "PutScalingPolicyOutput", DryRunUnsupported: true, OutputExtractor: "aws.StringValue(output.PolicyARN)",
				RequiredParams: []param{
					{AwsField: "AdjustmentType", TemplateName: "adjustment-type", AwsType: "awsstr"},
					{AwsField: "AutoScalingGroupName", TemplateName: "scalinggroup", AwsType: "awsstr"},
					{AwsField: "PolicyName", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "ScalingAdjustment", TemplateName: "adjustment-scaling", AwsType: "awsint64"},
				},
				ExtraParams: []param{
					{AwsField: "Cooldown", TemplateName: "cooldown", AwsType: "awsint64"},
					{AwsField: "MetricAggregationType", TemplateName: "metric-aggregation", AwsType: "awsstr"},
					{AwsField: "MinAdjustmentMagnitude", TemplateName: "adjustment-magnitude", AwsType: "awsint64"},
				},
			},
			{
				Action: "delete", Entity: cloud.ScalingPolicy, ApiMethod: "DeletePolicy", Input: "DeletePolicyInput", Output: "DeletePolicyOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "PolicyName", TemplateName: "id", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api: "rds",
		Drivers: []driver{

			{
				Action: "create", Entity: cloud.Database, Input: "CreateDBInstanceInput", Output: "CreateDBInstanceOutput", ApiMethod: "CreateDBInstance", DryRunUnsupported: true, OutputExtractor: "aws.StringValue(output.DBInstance.DBInstanceIdentifier)",
				RequiredParams: []param{
					{AwsField: "DBInstanceClass", TemplateName: "type", AwsType: "awsstr"},
					{AwsField: "DBInstanceIdentifier", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "Engine", TemplateName: "engine", AwsType: "awsstr"},
					{AwsField: "MasterUserPassword", TemplateName: "password", AwsType: "awsstr"},
					{AwsField: "MasterUsername", TemplateName: "username", AwsType: "awsstr"},
					{AwsField: "AllocatedStorage", TemplateName: "size", AwsType: "awsint64"},
				},
				ExtraParams: []param{
					{AwsField: "AutoMinorVersionUpgrade", TemplateName: "autoupgrade", AwsType: "awsbool"},
					{AwsField: "AvailabilityZone", TemplateName: "availabilityzone", AwsType: "awsstr"},
					{AwsField: "BackupRetentionPeriod", TemplateName: "backupretention", AwsType: "awsint64"},
					{AwsField: "DBClusterIdentifier", TemplateName: "cluster", AwsType: "awsstr"},
					{AwsField: "DBName", TemplateName: "dbname", AwsType: "awsstr"},
					{AwsField: "DBParameterGroupName", TemplateName: "parametergroup", AwsType: "awsstr"},
					{AwsField: "DBSecurityGroups", TemplateName: "dbsecuritygroups", AwsType: "awsstringslice"},
					{AwsField: "DBSubnetGroupName", TemplateName: "subnetgroup", AwsType: "awsstr"},
					{AwsField: "Domain", TemplateName: "domain", AwsType: "awsstr"},
					{AwsField: "DomainIAMRoleName", TemplateName: "iamrole", AwsType: "awsstr"},
					{AwsField: "EngineVersion", TemplateName: "version", AwsType: "awsstr"},
					{AwsField: "Iops", TemplateName: "iops", AwsType: "awsint64"},
					{AwsField: "LicenseModel", TemplateName: "license", AwsType: "awsstr"},
					{AwsField: "MultiAZ", TemplateName: "multiaz", AwsType: "awsbool"},
					{AwsField: "OptionGroupName", TemplateName: "optiongroup", AwsType: "awsstr"},
					{AwsField: "Port", TemplateName: "port", AwsType: "awsint64"},
					{AwsField: "PreferredBackupWindow", TemplateName: "backupwindow", AwsType: "awsstr"},
					{AwsField: "PreferredMaintenanceWindow", TemplateName: "maintenancewindow", AwsType: "awsstr"},
					{AwsField: "PubliclyAccessible", TemplateName: "public", AwsType: "awsbool"},
					{AwsField: "StorageEncrypted", TemplateName: "encrypted", AwsType: "awsbool"},
					{AwsField: "StorageType", TemplateName: "storagetype", AwsType: "awsstr"},
					{AwsField: "Timezone", TemplateName: "timezone", AwsType: "awsstr"},
					{AwsField: "VpcSecurityGroupIds", TemplateName: "vpcsecuritygroups", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "delete", Entity: cloud.Database, ApiMethod: "DeleteDBInstance", Input: "DeleteDBInstanceInput", Output: "DeleteDBInstanceOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "DBInstanceIdentifier", TemplateName: "id", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "SkipFinalSnapshot", TemplateName: "skipsnapshot", AwsType: "awsbool"},
					{AwsField: "FinalDBSnapshotIdentifier", TemplateName: "snapshotid", AwsType: "awsbool"},
				},
			},
			{
				Action: "create", Entity: cloud.DbSubnetGroup, ApiMethod: "CreateDBSubnetGroup", Input: "CreateDBSubnetGroupInput", Output: "CreateDBSubnetGroupOutput", DryRunUnsupported: true, OutputExtractor: "aws.StringValue(output.DBSubnetGroup.DBSubnetGroupName)",
				RequiredParams: []param{
					{AwsField: "DBSubnetGroupDescription", TemplateName: "description", AwsType: "awsstr"},
					{AwsField: "DBSubnetGroupName", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "SubnetIds", TemplateName: "subnets", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "delete", Entity: cloud.DbSubnetGroup, ApiMethod: "DeleteDBSubnetGroup", Input: "DeleteDBSubnetGroupInput", Output: "DeleteDBSubnetGroupOutput", DryRunUnsupported: true,
				RequiredParams: []param{
					{AwsField: "DBSubnetGroupName", TemplateName: "id", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api:     "sts",
		Drivers: []driver{},
	},
	{
		Api: "iam",
		Drivers: []driver{

			{
				Action: "create", Entity: cloud.User, DryRunUnsupported: true, Input: "CreateUserInput", Output: "CreateUserOutput", ApiMethod: "CreateUser", OutputExtractor: "aws.StringValue(output.User.UserId)",
				RequiredParams: []param{
					{AwsField: "UserName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.User, DryRunUnsupported: true, Input: "DeleteUserInput", Output: "DeleteUserOutput", ApiMethod: "DeleteUser",
				RequiredParams: []param{
					{AwsField: "UserName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.User, DryRunUnsupported: true, Input: "AddUserToGroupInput", Output: "AddUserToGroupOutput", ApiMethod: "AddUserToGroup",
				RequiredParams: []param{
					{AwsField: "GroupName", TemplateName: "group", AwsType: "awsstr"},
					{AwsField: "UserName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "detach", Entity: cloud.User, DryRunUnsupported: true, Input: "RemoveUserFromGroupInput", Output: "RemoveUserFromGroupOutput", ApiMethod: "RemoveUserFromGroup",
				RequiredParams: []param{
					{AwsField: "GroupName", TemplateName: "group", AwsType: "awsstr"},
					{AwsField: "UserName", TemplateName: "name", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.AccessKey, DryRunUnsupported: true, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "user"},
				},
			},
			{
				Action: "delete", Entity: cloud.AccessKey, DryRunUnsupported: true, ApiMethod: "DeleteAccessKey", Input: "DeleteAccessKeyInput", Output: "DeleteAccessKeyOutput",
				RequiredParams: []param{
					{AwsField: "AccessKeyId", TemplateName: "id", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.LoginProfile, DryRunUnsupported: true, Input: "CreateLoginProfileInput", Output: "CreateLoginProfileOutput", ApiMethod: "CreateLoginProfile", OutputExtractor: "aws.StringValue(output.LoginProfile.UserName)",
				RequiredParams: []param{
					{AwsField: "UserName", TemplateName: "username", AwsType: "awsstr"},
					{AwsField: "Password", TemplateName: "password", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "PasswordResetRequired", TemplateName: "password-reset", AwsType: "awsbool"},
				},
			},
			{
				Action: "update", Entity: cloud.LoginProfile, DryRunUnsupported: true, Input: "UpdateLoginProfileInput", Output: "UpdateLoginProfileOutput", ApiMethod: "UpdateLoginProfile",
				RequiredParams: []param{
					{AwsField: "UserName", TemplateName: "username", AwsType: "awsstr"},
					{AwsField: "Password", TemplateName: "password", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "PasswordResetRequired", TemplateName: "password-reset", AwsType: "awsbool"},
				},
			},
			{
				Action: "delete", Entity: cloud.LoginProfile, DryRunUnsupported: true, ApiMethod: "DeleteLoginProfile", Input: "DeleteLoginProfileInput", Output: "DeleteLoginProfileOutput",
				RequiredParams: []param{
					{AwsField: "UserName", TemplateName: "username", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.Group, DryRunUnsupported: true, Input: "CreateGroupInput", Output: "CreateGroupOutput", ApiMethod: "CreateGroup", OutputExtractor: "aws.StringValue(output.Group.GroupId)",
				RequiredParams: []param{
					{AwsField: "GroupName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.Group, DryRunUnsupported: true, Input: "DeleteGroupInput", Output: "DeleteGroupOutput", ApiMethod: "DeleteGroup",
				RequiredParams: []param{
					{AwsField: "GroupName", TemplateName: "name", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.Role, ManualFuncDefinition: true,
				RequiredParams: []param{
					{AwsField: "RoleName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{TemplateName: "principal-account"},
					{TemplateName: "principal-user"},
					{TemplateName: "principal-service"},
					{TemplateName: "sleep-after"},
				},
			},
			{
				Action: "delete", Entity: cloud.Role, ManualFuncDefinition: true,
				RequiredParams: []param{
					{AwsField: "RoleName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.Role, DryRunUnsupported: true, Input: "AddRoleToInstanceProfileInput", Output: "AddRoleToInstanceProfileOutput", ApiMethod: "AddRoleToInstanceProfile",
				RequiredParams: []param{
					{AwsField: "InstanceProfileName", TemplateName: "instanceprofile", AwsType: "awsstr"},
					{AwsField: "RoleName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "detach", Entity: cloud.Role, DryRunUnsupported: true, Input: "RemoveRoleFromInstanceProfileInput", Output: "RemoveRoleFromInstanceProfileOutput", ApiMethod: "RemoveRoleFromInstanceProfile",
				RequiredParams: []param{
					{AwsField: "InstanceProfileName", TemplateName: "instanceprofile", AwsType: "awsstr"},
					{AwsField: "RoleName", TemplateName: "name", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.InstanceProfile, DryRunUnsupported: true, Input: "CreateInstanceProfileInput", Output: "CreateInstanceProfileOutput", ApiMethod: "CreateInstanceProfile",
				RequiredParams: []param{
					{AwsField: "InstanceProfileName", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.InstanceProfile, DryRunUnsupported: true, Input: "DeleteInstanceProfileInput", Output: "DeleteInstanceProfileOutput", ApiMethod: "DeleteInstanceProfile",
				RequiredParams: []param{
					{AwsField: "InstanceProfileName", TemplateName: "name", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.Policy, ManualFuncDefinition: true,
				RequiredParams: []param{
					{AwsField: "PolicyName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Description", TemplateName: "description", AwsType: "awsstr"},
					{TemplateName: "effect"},
					{TemplateName: "action"},
					{TemplateName: "resource"},
				},
			},
			{
				Action: "delete", Entity: cloud.Policy, DryRunUnsupported: true, Input: "DeletePolicyInput", Output: "DeletePolicyOutput", ApiMethod: "DeletePolicy",
				RequiredParams: []param{
					{AwsField: "PolicyArn", TemplateName: "arn", AwsType: "awsstr"},
				},
			},
			{
				Action: "attach", Entity: cloud.Policy, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "arn"},
				},
				ExtraParams: []param{
					{TemplateName: "user"},
					{TemplateName: "group"},
					{TemplateName: "role"},
				},
			},
			{
				Action: "detach", Entity: cloud.Policy, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "arn"},
				},
				ExtraParams: []param{
					{TemplateName: "user"},
					{TemplateName: "group"},
					{TemplateName: "role"},
				},
			},
		},
	},
	{
		Api: "s3",
		Drivers: []driver{

			{
				Action: "create", Entity: cloud.Bucket, DryRunUnsupported: true, Input: "CreateBucketInput", Output: "CreateBucketOutput", ApiMethod: "CreateBucket", OutputExtractor: "params[\"name\"]",
				RequiredParams: []param{
					{AwsField: "Bucket", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "ACL", TemplateName: "acl", AwsType: "awsstr"},
				},
			},
			{
				Action: "update", Entity: cloud.Bucket, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "name"},
				},
				ExtraParams: []param{
					{TemplateName: "acl"},
					{TemplateName: "public-website"},
					{TemplateName: "redirect-hostname"},
					{TemplateName: "index-suffix"},
					{TemplateName: "enforce-https"},
				},
			},
			{
				Action: "delete", Entity: cloud.Bucket, DryRunUnsupported: true, Input: "DeleteBucketInput", Output: "DeleteBucketOutput", ApiMethod: "DeleteBucket",
				RequiredParams: []param{
					{AwsField: "Bucket", TemplateName: "name", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.S3Object, ManualFuncDefinition: true,
				RequiredParams: []param{
					{AwsField: "Bucket", TemplateName: "bucket", AwsType: "awsstr"},
					{AwsField: "Body", TemplateName: "file", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Key", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "ACL", TemplateName: "acl", AwsType: "awsstr"},
				},
			},
			{
				Action: "update", Entity: cloud.S3Object, DryRunUnsupported: true, Input: "PutObjectAclInput", Output: "PutObjectAclOutput", ApiMethod: "PutObjectAcl",
				RequiredParams: []param{
					{AwsField: "Bucket", TemplateName: "bucket", AwsType: "awsstr"},
					{AwsField: "Key", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "ACL", TemplateName: "acl", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "VersionId", TemplateName: "version", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.S3Object, DryRunUnsupported: true, Input: "DeleteObjectInput", Output: "DeleteObjectOutput", ApiMethod: "DeleteObject",
				RequiredParams: []param{
					{AwsField: "Bucket", TemplateName: "bucket", AwsType: "awsstr"},
					{AwsField: "Key", TemplateName: "name", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api: "sns",
		Drivers: []driver{

			{
				Action: "create", Entity: cloud.Topic, DryRunUnsupported: true, Input: "CreateTopicInput", Output: "CreateTopicOutput", ApiMethod: "CreateTopic", OutputExtractor: "aws.StringValue(output.TopicArn)",
				RequiredParams: []param{
					{AwsField: "Name", TemplateName: "name", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.Topic, DryRunUnsupported: true, Input: "DeleteTopicInput", Output: "DeleteTopicOutput", ApiMethod: "DeleteTopic",
				RequiredParams: []param{
					{AwsField: "TopicArn", TemplateName: "id", AwsType: "awsstr"},
				},
			},

			{
				Action: "create", Entity: cloud.Subscription, DryRunUnsupported: true, Input: "SubscribeInput", Output: "SubscribeOutput", ApiMethod: "Subscribe", OutputExtractor: "aws.StringValue(output.SubscriptionArn)",
				RequiredParams: []param{
					{AwsField: "TopicArn", TemplateName: "topic", AwsType: "awsstr"},
					{AwsField: "Endpoint", TemplateName: "endpoint", AwsType: "awsstr"},
					{AwsField: "Protocol", TemplateName: "protocol", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.Subscription, DryRunUnsupported: true, Input: "UnsubscribeInput", Output: "UnsubscribeOutput", ApiMethod: "Unsubscribe",
				RequiredParams: []param{
					{AwsField: "SubscriptionArn", TemplateName: "id", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api: "sqs",
		Drivers: []driver{

			{
				Action: "create", Entity: cloud.Queue, DryRunUnsupported: true, Input: "CreateQueueInput", Output: "CreateQueueOutput", ApiMethod: "CreateQueue", OutputExtractor: "aws.StringValue(output.QueueUrl)",
				RequiredParams: []param{
					{AwsField: "QueueName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Attributes[DelaySeconds]", TemplateName: "delay", AwsType: "awsstringpointermap"},
					{AwsField: "Attributes[MaximumMessageSize]", TemplateName: "maxMsgSize", AwsType: "awsstringpointermap"},
					{AwsField: "Attributes[MessageRetentionPeriod]", TemplateName: "retentionPeriod", AwsType: "awsstringpointermap"},
					{AwsField: "Attributes[Policy]", TemplateName: "policy", AwsType: "awsstringpointermap"},
					{AwsField: "Attributes[ReceiveMessageWaitTimeSeconds]", TemplateName: "msgWait", AwsType: "awsstringpointermap"},
					{AwsField: "Attributes[RedrivePolicy]", TemplateName: "redrivePolicy", AwsType: "awsstringpointermap"},
					{AwsField: "Attributes[VisibilityTimeout]", TemplateName: "visibilityTimeout", AwsType: "awsstringpointermap"},
				},
			},
			{
				Action: "delete", Entity: cloud.Queue, DryRunUnsupported: true, Input: "DeleteQueueInput", Output: "DeleteQueueOutput", ApiMethod: "DeleteQueue",
				RequiredParams: []param{
					{AwsField: "QueueUrl", TemplateName: "url", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api:          "route53",
		ApiInterface: "Route53API",
		Drivers: []driver{
			{
				Action: "create", Entity: cloud.Zone, DryRunUnsupported: true, Input: "CreateHostedZoneInput", Output: "CreateHostedZoneOutput", ApiMethod: "CreateHostedZone", OutputExtractor: "aws.StringValue(output.HostedZone.Id)",
				RequiredParams: []param{
					{AwsField: "CallerReference", TemplateName: "callerreference", AwsType: "awsstr"},
					{AwsField: "Name", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "DelegationSetId", TemplateName: "delegationsetid", AwsType: "awsstr"},
					{AwsField: "HostedZoneConfig.Comment", TemplateName: "comment", AwsType: "awsstr"},
					{AwsField: "HostedZoneConfig.PrivateZone", TemplateName: "isprivate", AwsType: "awsbool"},
					{AwsField: "VPC.VPCId", TemplateName: "vpcid", AwsType: "awsstr"},
					{AwsField: "VPC.VPCRegion", TemplateName: "vpcregion", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.Zone, DryRunUnsupported: true, Input: "DeleteHostedZoneInput", Output: "DeleteHostedZoneOutput", ApiMethod: "DeleteHostedZone",
				RequiredParams: []param{
					{AwsField: "Id", TemplateName: "id", AwsType: "awsstr"},
				},
			},
			{
				Action: "create", Entity: cloud.Record, DryRunUnsupported: true, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "zone"},
					{TemplateName: "name"},
					{TemplateName: "type"},
					{TemplateName: "value"},
					{TemplateName: "ttl"},
				},
				ExtraParams: []param{
					{TemplateName: "comment"},
				},
			},
			{
				Action: "delete", Entity: cloud.Record, DryRunUnsupported: true, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "zone"},
					{TemplateName: "name"},
					{TemplateName: "type"},
					{TemplateName: "value"},
					{TemplateName: "ttl"},
				},
			},
		},
	},
	{
		Api:          "lambda",
		ApiInterface: "LambdaAPI",
		Drivers: []driver{
			{
				Action: "create", Entity: cloud.Function, DryRunUnsupported: true, ApiMethod: "CreateFunction", Input: "CreateFunctionInput", Output: "FunctionConfiguration", OutputExtractor: "aws.StringValue(output.FunctionArn)",
				RequiredParams: []param{
					{AwsField: "FunctionName", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "Handler", TemplateName: "handler", AwsType: "awsstr"},
					{AwsField: "Role", TemplateName: "role", AwsType: "awsstr"},
					{AwsField: "Runtime", TemplateName: "runtime", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Code.S3Bucket", TemplateName: "bucket", AwsType: "awsstr"},
					{AwsField: "Code.S3Key", TemplateName: "object", AwsType: "awsstr"},
					{AwsField: "Code.S3ObjectVersion", TemplateName: "objectversion", AwsType: "awsstr"},
					{AwsField: "Code.ZipFile", TemplateName: "zipfile", AwsType: "awsfiletobyteslice"},
					{AwsField: "Description", TemplateName: "description", AwsType: "awsstr"},
					{AwsField: "MemorySize", TemplateName: "memory", AwsType: "awsint64"},
					{AwsField: "Publish", TemplateName: "publish", AwsType: "awsbool"},
					{AwsField: "Timeout", TemplateName: "timeout", AwsType: "awsint64"},
				},
			},
			{
				Action: "delete", Entity: cloud.Function, DryRunUnsupported: true, ApiMethod: "DeleteFunction", Input: "DeleteFunctionInput", Output: "DeleteFunctionOutput",
				RequiredParams: []param{
					{AwsField: "FunctionName", TemplateName: "id", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Qualifier", TemplateName: "version", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api:          "cloudwatch",
		ApiInterface: "CloudWatchAPI",
		Drivers: []driver{
			{
				Action: "create", Entity: cloud.Alarm, DryRunUnsupported: true, ApiMethod: "PutMetricAlarm", Input: "PutMetricAlarmInput", Output: "PutMetricAlarmOutput", OutputExtractor: "params[\"name\"]",
				RequiredParams: []param{
					{AwsField: "AlarmName", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "ComparisonOperator", TemplateName: "operator", AwsType: "awsstr"},
					{AwsField: "MetricName", TemplateName: "metric", AwsType: "awsstr"},
					{AwsField: "Namespace", TemplateName: "namespace", AwsType: "awsstr"},
					{AwsField: "EvaluationPeriods", TemplateName: "evaluation-periods", AwsType: "awsint64"},
					{AwsField: "Period", TemplateName: "period", AwsType: "awsint64"},
					{AwsField: "Statistic", TemplateName: "statistic-function", AwsType: "awsstr"},
					{AwsField: "Threshold", TemplateName: "threshold", AwsType: "awsfloat"},
				},
				ExtraParams: []param{
					{AwsField: "ActionsEnabled", TemplateName: "enabled", AwsType: "awsbool"},
					{AwsField: "AlarmActions", TemplateName: "alarm-actions", AwsType: "awsstringslice"},
					{AwsField: "InsufficientDataActions", TemplateName: "insufficientdata-actions", AwsType: "awsstringslice"},
					{AwsField: "OKActions", TemplateName: "ok-actions", AwsType: "awsstringslice"},
					{AwsField: "AlarmDescription", TemplateName: "description", AwsType: "awsstr"},
					{AwsField: "Dimensions", TemplateName: "dimensions", AwsType: "awsdimensionslice"},
					{AwsField: "Unit", TemplateName: "unit", AwsType: "awsstr"},
				},
			},
			{
				Action: "delete", Entity: cloud.Alarm, DryRunUnsupported: true, ApiMethod: "DeleteAlarms", Input: "DeleteAlarmsInput", Output: "DeleteAlarmsOutput",
				RequiredParams: []param{
					{AwsField: "AlarmNames", TemplateName: "name", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "start", Entity: cloud.Alarm, DryRunUnsupported: true, ApiMethod: "EnableAlarmActions", Input: "EnableAlarmActionsInput", Output: "EnableAlarmActionsOutput",
				RequiredParams: []param{
					{AwsField: "AlarmNames", TemplateName: "names", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "stop", Entity: cloud.Alarm, DryRunUnsupported: true, ApiMethod: "DisableAlarmActions", Input: "DisableAlarmActionsInput", Output: "DisableAlarmActionsOutput",
				RequiredParams: []param{
					{AwsField: "AlarmNames", TemplateName: "names", AwsType: "awsstringslice"},
				},
			},
			{
				Action: "attach", Entity: cloud.Alarm, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "name"},
					{TemplateName: "action-arn"},
				},
			},
			{
				Action: "detach", Entity: cloud.Alarm, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "name"},
					{TemplateName: "action-arn"},
				},
			},
		},
	},
	{
		Api:          "cloudfront",
		ApiInterface: "CloudFrontAPI",
		Drivers: []driver{
			{
				Action: "create", Entity: cloud.Distribution, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "origin-domain"},
				},
				ExtraParams: []param{
					{TemplateName: "certificate"},
					{TemplateName: "comment"},
					{TemplateName: "default-file"},
					{TemplateName: "domain-aliases"},
					{TemplateName: "enable"},
					{TemplateName: "forward-cookies"},
					{TemplateName: "forward-queries"},
					{TemplateName: "https-behaviour"},
					{TemplateName: "origin-path"},
					{TemplateName: "price-class"},
					{TemplateName: "min-ttl"},
				},
			},
			{
				Action: "check", Entity: cloud.Distribution, ManualFuncDefinition: true,
				RequiredParams: []param{
					{TemplateName: "id"},
					{TemplateName: "state"},
					{TemplateName: "timeout"},
				},
			},
			{
				Action: "update", Entity: cloud.Distribution, ManualFuncDefinition: true,
				RequiredParams: []param{
					{AwsField: "Id", TemplateName: "id", AwsType: "awsstr"},
					{AwsField: "DistributionConfig.Enabled", TemplateName: "enable", AwsType: "awsbool"},
				},
			},
			{
				Action: "delete", Entity: cloud.Distribution, ManualFuncDefinition: true,
				RequiredParams: []param{
					{AwsField: "Id", TemplateName: "id", AwsType: "awsstr"},
				},
			},
		},
	},
	{
		Api:          "cloudformation",
		ApiInterface: "CloudFormationAPI",
		Drivers: []driver{
			{
				Action: "create", Entity: cloud.Stack, DryRunUnsupported: true, ApiMethod: "CreateStack", Input: "CreateStackInput", Output: "CreateStackOutput", OutputExtractor: "aws.StringValue(output.StackId)",
				RequiredParams: []param{
					{AwsField: "StackName", TemplateName: "name", AwsType: "awsstr"},
					{AwsField: "TemplateBody", TemplateName: "template-file", AwsType: "awsfiletostring"},
				},
				ExtraParams: []param{
					{AwsField: "Capabilities", TemplateName: "capabilities", AwsType: "awsstringslice"},
					{AwsField: "DisableRollback", TemplateName: "disable-rollback", AwsType: "awsbool"},
					{AwsField: "NotificationARNs", TemplateName: "notifications", AwsType: "awsstringslice"},
					{AwsField: "OnFailure", TemplateName: "on-failure", AwsType: "awsstr"},
					{AwsField: "Parameters", TemplateName: "parameters", AwsType: "awsparameterslice"},
					{AwsField: "ResourceTypes", TemplateName: "resource-types", AwsType: "awsstringslice"},
					{AwsField: "RoleARN", TemplateName: "role", AwsType: "awsstr"},
					{AwsField: "StackPolicyBody", TemplateName: "policy-file", AwsType: "awsfiletostring"},
					{AwsField: "TimeoutInMinutes", TemplateName: "timeout", AwsType: "awsint64"},
				},
			},
			{
				Action: "update", Entity: cloud.Stack, DryRunUnsupported: true, ApiMethod: "UpdateStack", Input: "UpdateStackInput", Output: "UpdateStackOutput", OutputExtractor: "aws.StringValue(output.StackId)",
				RequiredParams: []param{
					{AwsField: "StackName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "Capabilities", TemplateName: "capabilities", AwsType: "awsstringslice"},
					{AwsField: "NotificationARNs", TemplateName: "notifications", AwsType: "awsstringslice"},
					{AwsField: "Parameters", TemplateName: "parameters", AwsType: "awsparameterslice"},
					{AwsField: "ResourceTypes", TemplateName: "resource-types", AwsType: "awsstringslice"},
					{AwsField: "RoleARN", TemplateName: "role", AwsType: "awsstr"},
					{AwsField: "StackPolicyBody", TemplateName: "policy-file", AwsType: "awsfiletostring"},
					{AwsField: "StackPolicyDuringUpdateBody", TemplateName: "policy-update-file", AwsType: "awsfiletostring"},
					{AwsField: "TemplateBody", TemplateName: "template-file", AwsType: "awsfiletostring"},
					{AwsField: "UsePreviousTemplate", TemplateName: "use-previous-template", AwsType: "awsbool"},
				},
			},
			{
				Action: "delete", Entity: cloud.Stack, DryRunUnsupported: true, ApiMethod: "DeleteStack", Input: "DeleteStackInput", Output: "DeleteStackOutput",
				RequiredParams: []param{
					{AwsField: "StackName", TemplateName: "name", AwsType: "awsstr"},
				},
				ExtraParams: []param{
					{AwsField: "RetainResources", TemplateName: "retain-resources", AwsType: "awsstringslice"},
				},
			},
		},
	},
}

var FetchersDefs = []fetchersDef{
	{
		Name:          "infra",
		Api:           []string{"ec2", "elbv2", "rds", "autoscaling"},
		ApiInterfaces: map[string]string{"autoscaling": "AutoScalingAPI"},
		Fetchers: []fetcher{
			{Api: "ec2", ResourceType: cloud.Instance, AWSType: "ec2.Instance", ApiMethod: "DescribeInstancesPages", Input: "ec2.DescribeInstancesInput{}", Output: "ec2.DescribeInstancesOutput", OutputsExtractor: "Instances", OutputsContainers: "Reservations", Multipage: true, NextPageMarker: "NextToken"},
			{Api: "ec2", ResourceType: cloud.Subnet, AWSType: "ec2.Subnet", ApiMethod: "DescribeSubnets", Input: "ec2.DescribeSubnetsInput{}", Output: "ec2.DescribeSubnetsOutput", OutputsExtractor: "Subnets"},
			{Api: "ec2", ResourceType: cloud.Vpc, AWSType: "ec2.Vpc", ApiMethod: "DescribeVpcs", Input: "ec2.DescribeVpcsInput{}", Output: "ec2.DescribeVpcsOutput", OutputsExtractor: "Vpcs"},
			{Api: "ec2", ResourceType: cloud.Keypair, AWSType: "ec2.KeyPairInfo", ApiMethod: "DescribeKeyPairs", Input: "ec2.DescribeKeyPairsInput{}", Output: "ec2.DescribeKeyPairsOutput", OutputsExtractor: "KeyPairs"},
			{Api: "ec2", ResourceType: cloud.SecurityGroup, AWSType: "ec2.SecurityGroup", ApiMethod: "DescribeSecurityGroups", Input: "ec2.DescribeSecurityGroupsInput{}", Output: "ec2.DescribeSecurityGroupsOutput", OutputsExtractor: "SecurityGroups"},
			{Api: "ec2", ResourceType: cloud.Volume, AWSType: "ec2.Volume", ApiMethod: "DescribeVolumesPages", Input: "ec2.DescribeVolumesInput{}", Output: "ec2.DescribeVolumesOutput", OutputsExtractor: "Volumes", Multipage: true, NextPageMarker: "NextToken"},
			{Api: "ec2", ResourceType: cloud.InternetGateway, AWSType: "ec2.InternetGateway", ApiMethod: "DescribeInternetGateways", Input: "ec2.DescribeInternetGatewaysInput{}", Output: "ec2.DescribeInternetGatewaysOutput", OutputsExtractor: "InternetGateways"},
			{Api: "ec2", ResourceType: cloud.RouteTable, AWSType: "ec2.RouteTable", ApiMethod: "DescribeRouteTables", Input: "ec2.DescribeRouteTablesInput{}", Output: "ec2.DescribeRouteTablesOutput", OutputsExtractor: "RouteTables"},
			{Api: "ec2", ResourceType: cloud.AvailabilityZone, AWSType: "ec2.AvailabilityZone", ApiMethod: "DescribeAvailabilityZones", Input: "ec2.DescribeAvailabilityZonesInput{}", Output: "ec2.DescribeAvailabilityZonesOutput", OutputsExtractor: "AvailabilityZones"},
			{Api: "ec2", ResourceType: cloud.Image, AWSType: "ec2.Image", ApiMethod: "DescribeImages", Input: "ec2.DescribeImagesInput{Owners: []*string{awssdk.String(\"self\")}}", Output: "ec2.DescribeImagesOutput", OutputsExtractor: "Images"},
			{Api: "ec2", ResourceType: cloud.ImportImageTask, AWSType: "ec2.ImportImageTask", ApiMethod: "DescribeImportImageTasks", Input: "ec2.DescribeImportImageTasksInput{}", Output: "ec2.DescribeImportImageTasksOutput", OutputsExtractor: "ImportImageTasks"},
			{Api: "ec2", ResourceType: cloud.ElasticIP, AWSType: "ec2.Address", ApiMethod: "DescribeAddresses", Input: "ec2.DescribeAddressesInput{}", Output: "ec2.DescribeAddressesOutput", OutputsExtractor: "Addresses"},
			{Api: "ec2", ResourceType: cloud.Snapshot, AWSType: "ec2.Snapshot", ApiMethod: "DescribeSnapshotsPages", Input: "ec2.DescribeSnapshotsInput{OwnerIds:[]*string{awssdk.String(\"self\")}}", Output: "ec2.DescribeSnapshotsOutput", OutputsExtractor: "Snapshots", Multipage: true, NextPageMarker: "NextToken"},
			{Api: "elbv2", ResourceType: cloud.LoadBalancer, AWSType: "elbv2.LoadBalancer", ApiMethod: "DescribeLoadBalancersPages", Input: "elbv2.DescribeLoadBalancersInput{}", Output: "elbv2.DescribeLoadBalancersOutput", OutputsExtractor: "LoadBalancers", Multipage: true, NextPageMarker: "NextMarker"},
			{Api: "elbv2", ResourceType: cloud.TargetGroup, AWSType: "elbv2.TargetGroup", ApiMethod: "DescribeTargetGroups", Input: "elbv2.DescribeTargetGroupsInput{}", Output: "elbv2.DescribeTargetGroupsOutput", OutputsExtractor: "TargetGroups"},
			{Api: "elbv2", ResourceType: cloud.Listener, AWSType: "elbv2.Listener", ManualFetcher: true},
			{Api: "rds", ResourceType: cloud.Database, AWSType: "rds.DBInstance", ApiMethod: "DescribeDBInstancesPages", Input: "rds.DescribeDBInstancesInput{}", Output: "rds.DescribeDBInstancesOutput", OutputsExtractor: "DBInstances", Multipage: true, NextPageMarker: "Marker"},
			{Api: "rds", ResourceType: cloud.DbSubnetGroup, AWSType: "rds.DBSubnetGroup", ApiMethod: "DescribeDBSubnetGroupsPages", Input: "rds.DescribeDBSubnetGroupsInput{}", Output: "rds.DescribeDBSubnetGroupsOutput", OutputsExtractor: "DBSubnetGroups", Multipage: true, NextPageMarker: "Marker"},
			{Api: "autoscaling", ResourceType: cloud.LaunchConfiguration, AWSType: "autoscaling.LaunchConfiguration", ApiMethod: "DescribeLaunchConfigurationsPages", Input: "autoscaling.DescribeLaunchConfigurationsInput{}", Output: "autoscaling.DescribeLaunchConfigurationsOutput", OutputsExtractor: "LaunchConfigurations", Multipage: true, NextPageMarker: "NextToken"},
			{Api: "autoscaling", ResourceType: cloud.ScalingGroup, AWSType: "autoscaling.Group", ApiMethod: "DescribeAutoScalingGroupsPages", Input: "autoscaling.DescribeAutoScalingGroupsInput{}", Output: "autoscaling.DescribeAutoScalingGroupsOutput", OutputsExtractor: "AutoScalingGroups", Multipage: true, NextPageMarker: "NextToken"},
			{Api: "autoscaling", ResourceType: cloud.ScalingPolicy, AWSType: "autoscaling.ScalingPolicy", ApiMethod: "DescribePoliciesPages", Input: "autoscaling.DescribePoliciesInput{}", Output: "autoscaling.DescribePoliciesOutput", OutputsExtractor: "ScalingPolicies", Multipage: true, NextPageMarker: "NextToken"},
		},
	},
	{
		Name: "access",
		Api:  []string{"iam", "sts"},
		Fetchers: []fetcher{
			{Api: "iam", ResourceType: cloud.User, AWSType: "iam.UserDetail", ManualFetcher: true},
			{Api: "iam", ResourceType: cloud.Group, AWSType: "iam.GroupDetail", ApiMethod: "GetAccountAuthorizationDetailsPages", Input: "iam.GetAccountAuthorizationDetailsInput{Filter: []*string{awssdk.String(iam.EntityTypeGroup)}}", Output: "iam.GetAccountAuthorizationDetailsOutput", OutputsExtractor: "GroupDetailList", Multipage: true, NextPageMarker: "Marker"},
			{Api: "iam", ResourceType: cloud.Role, AWSType: "iam.RoleDetail", ApiMethod: "GetAccountAuthorizationDetailsPages", Input: "iam.GetAccountAuthorizationDetailsInput{Filter: []*string{awssdk.String(iam.EntityTypeRole)}}", Output: "iam.GetAccountAuthorizationDetailsOutput", OutputsExtractor: "RoleDetailList", Multipage: true, NextPageMarker: "Marker"},
			{Api: "iam", ResourceType: cloud.Policy, AWSType: "iam.Policy", ApiMethod: "ListPoliciesPages", Input: "iam.ListPoliciesInput{OnlyAttached: awssdk.Bool(true)}", Output: "iam.ListPoliciesOutput", OutputsExtractor: "Policies", Multipage: true, NextPageMarker: "Marker"},
			{Api: "iam", ResourceType: cloud.AccessKey, AWSType: "iam.AccessKeyMetadata", ApiMethod: "ListAccessKeysPages", Input: "iam.ListAccessKeysInput{}", Output: "iam.ListAccessKeysOutput", OutputsExtractor: "AccessKeyMetadata", Multipage: true, NextPageMarker: "Marker"},
		},
	},
	{
		Name: "storage",
		Api:  []string{"s3"},
		Fetchers: []fetcher{
			{Api: "s3", ResourceType: cloud.Bucket, AWSType: "s3.Bucket", ManualFetcher: true},
			{Api: "s3", ResourceType: cloud.S3Object, AWSType: "s3.Object", ManualFetcher: true},
		},
	},
	{
		Name: "notification",
		Api:  []string{"sns"},
		Fetchers: []fetcher{
			{Api: "sns", ResourceType: cloud.Subscription, AWSType: "sns.Subscription", ApiMethod: "ListSubscriptionsPages", Input: "sns.ListSubscriptionsInput{}", Output: "sns.ListSubscriptionsOutput", OutputsExtractor: "Subscriptions", Multipage: true, NextPageMarker: "NextToken"},
			{Api: "sns", ResourceType: cloud.Topic, AWSType: "sns.Topic", ApiMethod: "ListTopicsPages", Input: "sns.ListTopicsInput{}", Output: "sns.ListTopicsOutput", OutputsExtractor: "Topics", Multipage: true, NextPageMarker: "NextToken"},
		},
	},
	{
		Name: "queue",
		Api:  []string{"sqs"},
		Fetchers: []fetcher{
			{Api: "sqs", ResourceType: cloud.Queue, AWSType: "string", ManualFetcher: true},
		},
	},
	{
		Name:          "dns",
		Api:           []string{"route53"},
		ApiInterfaces: map[string]string{"route53": "Route53API"},
		Fetchers: []fetcher{
			{Api: "route53", ResourceType: cloud.Zone, AWSType: "route53.HostedZone", ApiMethod: "ListHostedZonesPages", Input: "route53.ListHostedZonesInput{}", Output: "route53.ListHostedZonesOutput", OutputsExtractor: "HostedZones", Multipage: true, NextPageMarker: "NextMarker"},
			{Api: "route53", ResourceType: cloud.Record, AWSType: "route53.ResourceRecordSet", ManualFetcher: true},
		},
	},

	{
		Name:          "lambda",
		Api:           []string{"lambda"},
		ApiInterfaces: map[string]string{"lambda": "LambdaAPI"},
		Fetchers: []fetcher{
			{Api: "lambda", ResourceType: cloud.Function, AWSType: "lambda.FunctionConfiguration", ApiMethod: "ListFunctionsPages", Input: "lambda.ListFunctionsInput{}", Output: "lambda.ListFunctionsOutput", OutputsExtractor: "Functions", Multipage: true, NextPageMarker: "NextMarker"},
		},
	},
	{
		Name:          "monitoring",
		Api:           []string{"cloudwatch"},
		ApiInterfaces: map[string]string{"cloudwatch": "CloudWatchAPI"},
		Fetchers: []fetcher{
			{Api: "cloudwatch", ResourceType: cloud.Metric, AWSType: "cloudwatch.Metric", ApiMethod: "ListMetricsPages", Input: "cloudwatch.ListMetricsInput{}", Output: "cloudwatch.ListMetricsOutput", OutputsExtractor: "Metrics", Multipage: true, NextPageMarker: "NextToken"},
			{Api: "cloudwatch", ResourceType: cloud.Alarm, AWSType: "cloudwatch.MetricAlarm", ApiMethod: "DescribeAlarmsPages", Input: "cloudwatch.DescribeAlarmsInput{}", Output: "cloudwatch.DescribeAlarmsOutput", OutputsExtractor: "MetricAlarms", Multipage: true, NextPageMarker: "NextToken"},
		},
	},
	{
		Name:          "cdn",
		Api:           []string{"cloudfront"},
		ApiInterfaces: map[string]string{"cloudfront": "CloudFrontAPI"},
		Fetchers: []fetcher{
			{Api: "cloudfront", ResourceType: cloud.Distribution, AWSType: "cloudfront.DistributionSummary", ApiMethod: "ListDistributionsPages", Input: "cloudfront.ListDistributionsInput{}", Output: "cloudfront.ListDistributionsOutput", OutputsExtractor: "DistributionList.Items", Multipage: true, NextPageMarker: "DistributionList.NextMarker"},
		},
	},
	{
		Name:          "cloudformation",
		Api:           []string{"cloudformation"},
		ApiInterfaces: map[string]string{"cloudformation": "CloudFormationAPI"},
		Fetchers: []fetcher{
			{Api: "cloudformation", ResourceType: cloud.Stack, AWSType: "cloudformation.Stack", ApiMethod: "DescribeStacksPages", Input: "cloudformation.DescribeStacksInput{}", Output: "cloudformation.DescribeStacksOutput", OutputsExtractor: "Stacks", Multipage: true, NextPageMarker: "NextToken"},
		},
	},
}

var PropertiesDefinitions = []property{}/* 174 elements not displayed */

Functions

func Mocks

func Mocks() []*mockDef