awsspec

package
v0.1.6 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 16, 2017 License: Apache-2.0 Imports: 71 Imported by: 0

Documentation

Overview

DO NOT EDIT This file was automatically generated with go generate

DO NOT EDIT This file was automatically generated with go generate

DO NOT EDIT This file was automatically generated with go generate

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.

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.

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.

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

Constants

This section is empty.

Variables

View Source
var APIPerTemplateDefName = map[string]string{}/* 155 elements not displayed */
View Source
var (
	AWSCredFilepath = filepath.Join(awsHomeDir(), "credentials")
)
View Source
var AWSTemplatesDefinitions = map[string]Definition{}/* 155 elements not displayed */
View Source
var CallerReferenceFunc = func() string {
	return fmt.Sprint(time.Now().UTC().Unix())
}
View Source
var DriverSupportedActions = map[string][]string{
	"attach":       {"alarm", "containertask", "elasticip", "instance", "instanceprofile", "internetgateway", "mfadevice", "networkinterface", "policy", "role", "routetable", "securitygroup", "user", "volume"},
	"authenticate": {"registry"},
	"check":        {"certificate", "database", "distribution", "instance", "loadbalancer", "natgateway", "networkinterface", "scalinggroup", "securitygroup", "volume"},
	"copy":         {"image", "snapshot"},
	"create":       {"accesskey", "alarm", "appscalingpolicy", "appscalingtarget", "bucket", "certificate", "containercluster", "database", "dbsubnetgroup", "distribution", "elasticip", "function", "group", "instance", "instanceprofile", "internetgateway", "keypair", "launchconfiguration", "listener", "loadbalancer", "loginprofile", "mfadevice", "natgateway", "networkinterface", "policy", "queue", "record", "repository", "role", "route", "routetable", "s3object", "scalinggroup", "scalingpolicy", "securitygroup", "snapshot", "stack", "subnet", "subscription", "tag", "targetgroup", "topic", "user", "volume", "vpc", "zone"},
	"delete":       {"accesskey", "alarm", "appscalingpolicy", "appscalingtarget", "bucket", "certificate", "containercluster", "containertask", "database", "dbsubnetgroup", "distribution", "elasticip", "function", "group", "image", "instance", "instanceprofile", "internetgateway", "keypair", "launchconfiguration", "listener", "loadbalancer", "loginprofile", "mfadevice", "natgateway", "networkinterface", "policy", "queue", "record", "repository", "role", "route", "routetable", "s3object", "scalinggroup", "scalingpolicy", "securitygroup", "snapshot", "stack", "subnet", "subscription", "tag", "targetgroup", "topic", "user", "volume", "vpc", "zone"},
	"detach":       {"alarm", "containertask", "elasticip", "instance", "instanceprofile", "internetgateway", "mfadevice", "networkinterface", "policy", "role", "routetable", "securitygroup", "user", "volume"},
	"import":       {"image"},
	"start":        {"alarm", "containertask", "instance"},
	"stop":         {"alarm", "containertask", "instance"},
	"update":       {"bucket", "containertask", "distribution", "instance", "loginprofile", "policy", "record", "s3object", "scalinggroup", "securitygroup", "stack", "subnet", "targetgroup"},
}
View Source
var NoSessionFactory = &AWSFactory{
	Log: logger.DiscardLogger,
}
View Source
var ProgressBarFactory func(*os.File) (*ProgressReadSeeker, error)

Allow to control for testing

Functions

func Bool

func Bool(v bool) *bool

func BoolValue

func BoolValue(v *bool) bool

func Int64

func Int64(v int64) *int64

func Int64AsIntValue

func Int64AsIntValue(v *int64) int

func NewCredsPrompter

func NewCredsPrompter(profile string) *credentialsPrompter

func NewEnumValidator

func NewEnumValidator(expected ...string) *enumValidator

func String

func String(v string) *string

func StringValue

func StringValue(v *string) string

Types

type AWSFactory

type AWSFactory struct {
	Log  *logger.Logger
	Sess *session.Session
}

func (*AWSFactory) Build

func (f *AWSFactory) Build(key string) func() interface{}

type AfterRunner

type AfterRunner interface {
	AfterRun(ctx map[string]interface{}, output interface{}) error
}

type AttachAlarm

type AttachAlarm struct {
	Name      *string `templateName:"name" required:""`
	ActionArn *string `templateName:"action-arn" required:""`
	// contains filtered or unexported fields
}

func NewAttachAlarm

func NewAttachAlarm(sess *session.Session, l ...*logger.Logger) *AttachAlarm

func (*AttachAlarm) DryRun

func (cmd *AttachAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachAlarm) ManualRun

func (cmd *AttachAlarm) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*AttachAlarm) ParamsHelp

func (cmd *AttachAlarm) ParamsHelp() string

func (*AttachAlarm) Run

func (cmd *AttachAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachAlarm) SetApi

func (cmd *AttachAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*AttachAlarm) ValidateCommand

func (cmd *AttachAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachAlarm) ValidateParams

func (cmd *AttachAlarm) ValidateParams(params []string) ([]string, error)

type AttachContainertask

type AttachContainertask struct {
	Name            *string   `templateName:"name" required:""`
	ContainerName   *string   `templateName:"container-name" required:""`
	Image           *string   `templateName:"image" required:""`
	MemoryHardLimit *int64    `templateName:"memory-hard-limit" required:""`
	Commands        []*string `templateName:"command"`
	Env             []*string `templateName:"env"`
	Privileged      *bool     `templateName:"privileged"`
	Workdir         *string   `templateName:"workdir"`
	Ports           []*string `templateName:"ports"`
	// contains filtered or unexported fields
}

func NewAttachContainertask

func NewAttachContainertask(sess *session.Session, l ...*logger.Logger) *AttachContainertask

func (*AttachContainertask) DryRun

func (cmd *AttachContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachContainertask) ExtractResult

func (cmd *AttachContainertask) ExtractResult(i interface{}) string

func (*AttachContainertask) ManualRun

func (cmd *AttachContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*AttachContainertask) ParamsHelp

func (cmd *AttachContainertask) ParamsHelp() string

func (*AttachContainertask) Run

func (cmd *AttachContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachContainertask) SetApi

func (cmd *AttachContainertask) SetApi(api ecsiface.ECSAPI)

func (*AttachContainertask) ValidateCommand

func (cmd *AttachContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachContainertask) ValidateParams

func (cmd *AttachContainertask) ValidateParams(params []string) ([]string, error)

type AttachElasticip

type AttachElasticip struct {
	Id                 *string `awsName:"AllocationId" awsType:"awsstr" templateName:"id" required:""`
	Instance           *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance"`
	Networkinterface   *string `awsName:"NetworkInterfaceId" awsType:"awsstr" templateName:"networkinterface"`
	Privateip          *string `awsName:"PrivateIpAddress" awsType:"awsstr" templateName:"privateip"`
	AllowReassociation *bool   `awsName:"AllowReassociation" awsType:"awsbool" templateName:"allow-reassociation"`
	// contains filtered or unexported fields
}

func NewAttachElasticip

func NewAttachElasticip(sess *session.Session, l ...*logger.Logger) *AttachElasticip

func (*AttachElasticip) DryRun

func (cmd *AttachElasticip) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachElasticip) ExtractResult

func (cmd *AttachElasticip) ExtractResult(i interface{}) string

func (*AttachElasticip) ParamsHelp

func (cmd *AttachElasticip) ParamsHelp() string

func (*AttachElasticip) Run

func (cmd *AttachElasticip) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachElasticip) SetApi

func (cmd *AttachElasticip) SetApi(api ec2iface.EC2API)

func (*AttachElasticip) ValidateCommand

func (cmd *AttachElasticip) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachElasticip) ValidateParams

func (cmd *AttachElasticip) ValidateParams(params []string) ([]string, error)

type AttachInstance

type AttachInstance struct {
	Targetgroup *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"targetgroup" required:""`
	Id          *string `awsName:"Targets[0]Id" awsType:"awsslicestruct" templateName:"id" required:""`
	Port        *int64  `awsName:"Targets[0]Port" awsType:"awsslicestructint64" templateName:"port"`
	// contains filtered or unexported fields
}

func NewAttachInstance

func NewAttachInstance(sess *session.Session, l ...*logger.Logger) *AttachInstance

func (*AttachInstance) DryRun

func (cmd *AttachInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachInstance) ParamsHelp

func (cmd *AttachInstance) ParamsHelp() string

func (*AttachInstance) Run

func (cmd *AttachInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachInstance) SetApi

func (cmd *AttachInstance) SetApi(api elbv2iface.ELBV2API)

func (*AttachInstance) ValidateCommand

func (cmd *AttachInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachInstance) ValidateParams

func (cmd *AttachInstance) ValidateParams(params []string) ([]string, error)

type AttachInstanceprofile

type AttachInstanceprofile struct {
	Instance *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance" required:""`
	Name     *string `awsName:"IamInstanceProfile.Name" awsType:"awsstr" templateName:"name" required:""`
	Replace  *bool   `templateName:"replace"`
	// contains filtered or unexported fields
}

func NewAttachInstanceprofile

func NewAttachInstanceprofile(sess *session.Session, l ...*logger.Logger) *AttachInstanceprofile

func (*AttachInstanceprofile) DryRun

func (cmd *AttachInstanceprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachInstanceprofile) ManualRun

func (cmd *AttachInstanceprofile) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*AttachInstanceprofile) ParamsHelp

func (cmd *AttachInstanceprofile) ParamsHelp() string

func (*AttachInstanceprofile) Run

func (cmd *AttachInstanceprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachInstanceprofile) SetApi

func (cmd *AttachInstanceprofile) SetApi(api ec2iface.EC2API)

func (*AttachInstanceprofile) ValidateCommand

func (cmd *AttachInstanceprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachInstanceprofile) ValidateParams

func (cmd *AttachInstanceprofile) ValidateParams(params []string) ([]string, error)

type AttachInternetgateway

type AttachInternetgateway struct {
	Id  *string `awsName:"InternetGatewayId" awsType:"awsstr" templateName:"id" required:""`
	Vpc *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc" required:""`
	// contains filtered or unexported fields
}

func NewAttachInternetgateway

func NewAttachInternetgateway(sess *session.Session, l ...*logger.Logger) *AttachInternetgateway

func (*AttachInternetgateway) DryRun

func (cmd *AttachInternetgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachInternetgateway) ParamsHelp

func (cmd *AttachInternetgateway) ParamsHelp() string

func (*AttachInternetgateway) Run

func (cmd *AttachInternetgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachInternetgateway) SetApi

func (cmd *AttachInternetgateway) SetApi(api ec2iface.EC2API)

func (*AttachInternetgateway) ValidateCommand

func (cmd *AttachInternetgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachInternetgateway) ValidateParams

func (cmd *AttachInternetgateway) ValidateParams(params []string) ([]string, error)

type AttachMfadevice

type AttachMfadevice struct {
	Id       *string `awsName:"SerialNumber" awsType:"awsstr" templateName:"id" required:""`
	User     *string `awsName:"UserName" awsType:"awsstr" templateName:"user" required:""`
	MfaCode1 *string `awsName:"AuthenticationCode1" awsType:"aws6digitsstring" templateName:"mfa-code-1" required:""`
	MfaCode2 *string `awsName:"AuthenticationCode2" awsType:"aws6digitsstring" templateName:"mfa-code-2" required:""`
	NoPrompt *bool   `templateName:"no-prompt"`
	// contains filtered or unexported fields
}

func NewAttachMfadevice

func NewAttachMfadevice(sess *session.Session, l ...*logger.Logger) *AttachMfadevice

func (*AttachMfadevice) AfterRun

func (cmd *AttachMfadevice) AfterRun(ctx map[string]interface{}, output interface{}) error

func (*AttachMfadevice) DryRun

func (cmd *AttachMfadevice) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachMfadevice) ParamsHelp

func (cmd *AttachMfadevice) ParamsHelp() string

func (*AttachMfadevice) Run

func (cmd *AttachMfadevice) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachMfadevice) SetApi

func (cmd *AttachMfadevice) SetApi(api iamiface.IAMAPI)

func (*AttachMfadevice) ValidateCommand

func (cmd *AttachMfadevice) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachMfadevice) ValidateParams

func (cmd *AttachMfadevice) ValidateParams(params []string) ([]string, error)

type AttachNetworkinterface

type AttachNetworkinterface struct {
	Id          *string `awsName:"NetworkInterfaceId" awsType:"awsstr" templateName:"id" required:""`
	Instance    *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance" required:""`
	DeviceIndex *int64  `awsName:"DeviceIndex" awsType:"awsint64" templateName:"device-index" required:""`
	// contains filtered or unexported fields
}

func NewAttachNetworkinterface

func NewAttachNetworkinterface(sess *session.Session, l ...*logger.Logger) *AttachNetworkinterface

func (*AttachNetworkinterface) DryRun

func (cmd *AttachNetworkinterface) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachNetworkinterface) ExtractResult

func (cmd *AttachNetworkinterface) ExtractResult(i interface{}) string

func (*AttachNetworkinterface) ParamsHelp

func (cmd *AttachNetworkinterface) ParamsHelp() string

func (*AttachNetworkinterface) Run

func (cmd *AttachNetworkinterface) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachNetworkinterface) SetApi

func (cmd *AttachNetworkinterface) SetApi(api ec2iface.EC2API)

func (*AttachNetworkinterface) ValidateCommand

func (cmd *AttachNetworkinterface) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachNetworkinterface) ValidateParams

func (cmd *AttachNetworkinterface) ValidateParams(params []string) ([]string, error)

type AttachPolicy

type AttachPolicy struct {
	Arn   *string `awsName:"PolicyArn" awsType:"awsstr" templateName:"arn"`
	User  *string `awsName:"UserName" awsType:"awsstr" templateName:"user"`
	Group *string `awsName:"GroupName" awsType:"awsstr" templateName:"group"`
	Role  *string `awsName:"RoleName" awsType:"awsstr" templateName:"role"`
	// contains filtered or unexported fields
}

func NewAttachPolicy

func NewAttachPolicy(sess *session.Session, l ...*logger.Logger) *AttachPolicy

func (*AttachPolicy) ConvertParams

func (cmd *AttachPolicy) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]interface{}, error))

func (*AttachPolicy) DryRun

func (cmd *AttachPolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachPolicy) ManualRun

func (cmd *AttachPolicy) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*AttachPolicy) ParamsHelp

func (cmd *AttachPolicy) ParamsHelp() string

func (*AttachPolicy) Run

func (cmd *AttachPolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachPolicy) SetApi

func (cmd *AttachPolicy) SetApi(api iamiface.IAMAPI)

func (*AttachPolicy) ValidateCommand

func (cmd *AttachPolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachPolicy) ValidateParams

func (cmd *AttachPolicy) ValidateParams(params []string) ([]string, error)

type AttachRole

type AttachRole struct {
	Instanceprofile *string `awsName:"InstanceProfileName" awsType:"awsstr" templateName:"instanceprofile" required:""`
	Name            *string `awsName:"RoleName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewAttachRole

func NewAttachRole(sess *session.Session, l ...*logger.Logger) *AttachRole

func (*AttachRole) DryRun

func (cmd *AttachRole) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachRole) ParamsHelp

func (cmd *AttachRole) ParamsHelp() string

func (*AttachRole) Run

func (cmd *AttachRole) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachRole) SetApi

func (cmd *AttachRole) SetApi(api iamiface.IAMAPI)

func (*AttachRole) ValidateCommand

func (cmd *AttachRole) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachRole) ValidateParams

func (cmd *AttachRole) ValidateParams(params []string) ([]string, error)

type AttachRoutetable

type AttachRoutetable struct {
	Id     *string `awsName:"RouteTableId" awsType:"awsstr" templateName:"id" required:""`
	Subnet *string `awsName:"SubnetId" awsType:"awsstr" templateName:"subnet" required:""`
	// contains filtered or unexported fields
}

func NewAttachRoutetable

func NewAttachRoutetable(sess *session.Session, l ...*logger.Logger) *AttachRoutetable

func (*AttachRoutetable) DryRun

func (cmd *AttachRoutetable) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachRoutetable) ExtractResult

func (cmd *AttachRoutetable) ExtractResult(i interface{}) string

func (*AttachRoutetable) ParamsHelp

func (cmd *AttachRoutetable) ParamsHelp() string

func (*AttachRoutetable) Run

func (cmd *AttachRoutetable) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachRoutetable) SetApi

func (cmd *AttachRoutetable) SetApi(api ec2iface.EC2API)

func (*AttachRoutetable) ValidateCommand

func (cmd *AttachRoutetable) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachRoutetable) ValidateParams

func (cmd *AttachRoutetable) ValidateParams(params []string) ([]string, error)

type AttachSecuritygroup

type AttachSecuritygroup struct {
	Id       *string `templateName:"id" required:""`
	Instance *string `templateName:"instance" required:""`
	// contains filtered or unexported fields
}

func NewAttachSecuritygroup

func NewAttachSecuritygroup(sess *session.Session, l ...*logger.Logger) *AttachSecuritygroup

func (*AttachSecuritygroup) DryRun

func (cmd *AttachSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachSecuritygroup) ManualRun

func (cmd *AttachSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*AttachSecuritygroup) ParamsHelp

func (cmd *AttachSecuritygroup) ParamsHelp() string

func (*AttachSecuritygroup) Run

func (cmd *AttachSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachSecuritygroup) SetApi

func (cmd *AttachSecuritygroup) SetApi(api ec2iface.EC2API)

func (*AttachSecuritygroup) ValidateCommand

func (cmd *AttachSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachSecuritygroup) ValidateParams

func (cmd *AttachSecuritygroup) ValidateParams(params []string) ([]string, error)

type AttachUser

type AttachUser struct {
	Group *string `awsName:"GroupName" awsType:"awsstr" templateName:"group" required:""`
	Name  *string `awsName:"UserName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewAttachUser

func NewAttachUser(sess *session.Session, l ...*logger.Logger) *AttachUser

func (*AttachUser) DryRun

func (cmd *AttachUser) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachUser) ParamsHelp

func (cmd *AttachUser) ParamsHelp() string

func (*AttachUser) Run

func (cmd *AttachUser) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachUser) SetApi

func (cmd *AttachUser) SetApi(api iamiface.IAMAPI)

func (*AttachUser) ValidateCommand

func (cmd *AttachUser) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachUser) ValidateParams

func (cmd *AttachUser) ValidateParams(params []string) ([]string, error)

type AttachVolume

type AttachVolume struct {
	Device   *string `awsName:"Device" awsType:"awsstr" templateName:"device" required:""`
	Id       *string `awsName:"VolumeId" awsType:"awsstr" templateName:"id" required:""`
	Instance *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance" required:""`
	// contains filtered or unexported fields
}

func NewAttachVolume

func NewAttachVolume(sess *session.Session, l ...*logger.Logger) *AttachVolume

func (*AttachVolume) DryRun

func (cmd *AttachVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachVolume) ExtractResult

func (cmd *AttachVolume) ExtractResult(i interface{}) string

func (*AttachVolume) ParamsHelp

func (cmd *AttachVolume) ParamsHelp() string

func (*AttachVolume) Run

func (cmd *AttachVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AttachVolume) SetApi

func (cmd *AttachVolume) SetApi(api ec2iface.EC2API)

func (*AttachVolume) ValidateCommand

func (cmd *AttachVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AttachVolume) ValidateParams

func (cmd *AttachVolume) ValidateParams(params []string) ([]string, error)

type AuthenticateRegistry

type AuthenticateRegistry struct {
	Accounts         []*string `templateName:"accounts"`
	NoConfirm        *bool     `templateName:"no-confirm"`
	DisableDockerCmd *bool     `templateName:"no-docker-login"`
	// contains filtered or unexported fields
}

func NewAuthenticateRegistry

func NewAuthenticateRegistry(sess *session.Session, l ...*logger.Logger) *AuthenticateRegistry

func (*AuthenticateRegistry) DryRun

func (cmd *AuthenticateRegistry) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*AuthenticateRegistry) ManualRun

func (cmd *AuthenticateRegistry) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*AuthenticateRegistry) ParamsHelp

func (cmd *AuthenticateRegistry) ParamsHelp() string

func (*AuthenticateRegistry) Run

func (cmd *AuthenticateRegistry) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*AuthenticateRegistry) SetApi

func (cmd *AuthenticateRegistry) SetApi(api ecriface.ECRAPI)

func (*AuthenticateRegistry) ValidateCommand

func (cmd *AuthenticateRegistry) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*AuthenticateRegistry) ValidateParams

func (cmd *AuthenticateRegistry) ValidateParams(params []string) ([]string, error)

type BeforeRunner

type BeforeRunner interface {
	BeforeRun(ctx map[string]interface{}) error
}

type CheckCertificate

type CheckCertificate struct {
	Arn     *string `templateName:"arn" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckCertificate

func NewCheckCertificate(sess *session.Session, l ...*logger.Logger) *CheckCertificate

func (*CheckCertificate) DryRun

func (cmd *CheckCertificate) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckCertificate) ManualRun

func (cmd *CheckCertificate) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckCertificate) ParamsHelp

func (cmd *CheckCertificate) ParamsHelp() string

func (*CheckCertificate) Run

func (cmd *CheckCertificate) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckCertificate) SetApi

func (cmd *CheckCertificate) SetApi(api acmiface.ACMAPI)

func (*CheckCertificate) ValidateCommand

func (cmd *CheckCertificate) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckCertificate) ValidateParams

func (cmd *CheckCertificate) ValidateParams(params []string) ([]string, error)

func (*CheckCertificate) Validate_State

func (cmd *CheckCertificate) Validate_State() error

type CheckDatabase

type CheckDatabase struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckDatabase

func NewCheckDatabase(sess *session.Session, l ...*logger.Logger) *CheckDatabase

func (*CheckDatabase) DryRun

func (cmd *CheckDatabase) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckDatabase) ManualRun

func (cmd *CheckDatabase) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckDatabase) ParamsHelp

func (cmd *CheckDatabase) ParamsHelp() string

func (*CheckDatabase) Run

func (cmd *CheckDatabase) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckDatabase) SetApi

func (cmd *CheckDatabase) SetApi(api rdsiface.RDSAPI)

func (*CheckDatabase) ValidateCommand

func (cmd *CheckDatabase) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckDatabase) ValidateParams

func (cmd *CheckDatabase) ValidateParams(params []string) ([]string, error)

func (*CheckDatabase) Validate_State

func (cmd *CheckDatabase) Validate_State() error

type CheckDistribution

type CheckDistribution struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckDistribution

func NewCheckDistribution(sess *session.Session, l ...*logger.Logger) *CheckDistribution

func (*CheckDistribution) DryRun

func (cmd *CheckDistribution) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckDistribution) ManualRun

func (cmd *CheckDistribution) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckDistribution) ParamsHelp

func (cmd *CheckDistribution) ParamsHelp() string

func (*CheckDistribution) Run

func (cmd *CheckDistribution) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckDistribution) SetApi

func (*CheckDistribution) ValidateCommand

func (cmd *CheckDistribution) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckDistribution) ValidateParams

func (cmd *CheckDistribution) ValidateParams(params []string) ([]string, error)

func (*CheckDistribution) Validate_State

func (cmd *CheckDistribution) Validate_State() error

type CheckInstance

type CheckInstance struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckInstance

func NewCheckInstance(sess *session.Session, l ...*logger.Logger) *CheckInstance

func (*CheckInstance) DryRun

func (cmd *CheckInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckInstance) ManualRun

func (cmd *CheckInstance) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckInstance) ParamsHelp

func (cmd *CheckInstance) ParamsHelp() string

func (*CheckInstance) Run

func (cmd *CheckInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckInstance) SetApi

func (cmd *CheckInstance) SetApi(api ec2iface.EC2API)

func (*CheckInstance) ValidateCommand

func (cmd *CheckInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckInstance) ValidateParams

func (cmd *CheckInstance) ValidateParams(params []string) ([]string, error)

func (*CheckInstance) Validate_State

func (cmd *CheckInstance) Validate_State() error

type CheckLoadbalancer

type CheckLoadbalancer struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckLoadbalancer

func NewCheckLoadbalancer(sess *session.Session, l ...*logger.Logger) *CheckLoadbalancer

func (*CheckLoadbalancer) DryRun

func (cmd *CheckLoadbalancer) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckLoadbalancer) ManualRun

func (cmd *CheckLoadbalancer) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckLoadbalancer) ParamsHelp

func (cmd *CheckLoadbalancer) ParamsHelp() string

func (*CheckLoadbalancer) Run

func (cmd *CheckLoadbalancer) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckLoadbalancer) SetApi

func (cmd *CheckLoadbalancer) SetApi(api elbv2iface.ELBV2API)

func (*CheckLoadbalancer) ValidateCommand

func (cmd *CheckLoadbalancer) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckLoadbalancer) ValidateParams

func (cmd *CheckLoadbalancer) ValidateParams(params []string) ([]string, error)

func (*CheckLoadbalancer) Validate_State

func (cmd *CheckLoadbalancer) Validate_State() error

type CheckNatgateway

type CheckNatgateway struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckNatgateway

func NewCheckNatgateway(sess *session.Session, l ...*logger.Logger) *CheckNatgateway

func (*CheckNatgateway) DryRun

func (cmd *CheckNatgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckNatgateway) ManualRun

func (cmd *CheckNatgateway) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckNatgateway) ParamsHelp

func (cmd *CheckNatgateway) ParamsHelp() string

func (*CheckNatgateway) Run

func (cmd *CheckNatgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckNatgateway) SetApi

func (cmd *CheckNatgateway) SetApi(api ec2iface.EC2API)

func (*CheckNatgateway) ValidateCommand

func (cmd *CheckNatgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckNatgateway) ValidateParams

func (cmd *CheckNatgateway) ValidateParams(params []string) ([]string, error)

func (*CheckNatgateway) Validate_State

func (cmd *CheckNatgateway) Validate_State() error

type CheckNetworkinterface

type CheckNetworkinterface struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckNetworkinterface

func NewCheckNetworkinterface(sess *session.Session, l ...*logger.Logger) *CheckNetworkinterface

func (*CheckNetworkinterface) DryRun

func (cmd *CheckNetworkinterface) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckNetworkinterface) ManualRun

func (cmd *CheckNetworkinterface) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckNetworkinterface) ParamsHelp

func (cmd *CheckNetworkinterface) ParamsHelp() string

func (*CheckNetworkinterface) Run

func (cmd *CheckNetworkinterface) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckNetworkinterface) SetApi

func (cmd *CheckNetworkinterface) SetApi(api ec2iface.EC2API)

func (*CheckNetworkinterface) ValidateCommand

func (cmd *CheckNetworkinterface) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckNetworkinterface) ValidateParams

func (cmd *CheckNetworkinterface) ValidateParams(params []string) ([]string, error)

func (*CheckNetworkinterface) Validate_State

func (cmd *CheckNetworkinterface) Validate_State() error

type CheckScalinggroup

type CheckScalinggroup struct {
	Name    *string `templateName:"name" required:""`
	Count   *int64  `templateName:"count" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckScalinggroup

func NewCheckScalinggroup(sess *session.Session, l ...*logger.Logger) *CheckScalinggroup

func (*CheckScalinggroup) DryRun

func (cmd *CheckScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckScalinggroup) ManualRun

func (sg *CheckScalinggroup) ManualRun(map[string]interface{}) (interface{}, error)

func (*CheckScalinggroup) ParamsHelp

func (cmd *CheckScalinggroup) ParamsHelp() string

func (*CheckScalinggroup) Run

func (cmd *CheckScalinggroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckScalinggroup) SetApi

func (*CheckScalinggroup) ValidateCommand

func (cmd *CheckScalinggroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckScalinggroup) ValidateParams

func (cmd *CheckScalinggroup) ValidateParams(params []string) ([]string, error)

type CheckSecuritygroup

type CheckSecuritygroup struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckSecuritygroup

func NewCheckSecuritygroup(sess *session.Session, l ...*logger.Logger) *CheckSecuritygroup

func (*CheckSecuritygroup) DryRun

func (cmd *CheckSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckSecuritygroup) ManualRun

func (cmd *CheckSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckSecuritygroup) ParamsHelp

func (cmd *CheckSecuritygroup) ParamsHelp() string

func (*CheckSecuritygroup) Run

func (cmd *CheckSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckSecuritygroup) SetApi

func (cmd *CheckSecuritygroup) SetApi(api ec2iface.EC2API)

func (*CheckSecuritygroup) ValidateCommand

func (cmd *CheckSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckSecuritygroup) ValidateParams

func (cmd *CheckSecuritygroup) ValidateParams(params []string) ([]string, error)

func (*CheckSecuritygroup) Validate_State

func (cmd *CheckSecuritygroup) Validate_State() error

type CheckVolume

type CheckVolume struct {
	Id      *string `templateName:"id" required:""`
	State   *string `templateName:"state" required:""`
	Timeout *int64  `templateName:"timeout" required:""`
	// contains filtered or unexported fields
}

func NewCheckVolume

func NewCheckVolume(sess *session.Session, l ...*logger.Logger) *CheckVolume

func (*CheckVolume) DryRun

func (cmd *CheckVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckVolume) ManualRun

func (cmd *CheckVolume) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CheckVolume) ParamsHelp

func (cmd *CheckVolume) ParamsHelp() string

func (*CheckVolume) Run

func (cmd *CheckVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CheckVolume) SetApi

func (cmd *CheckVolume) SetApi(api ec2iface.EC2API)

func (*CheckVolume) ValidateCommand

func (cmd *CheckVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CheckVolume) ValidateParams

func (cmd *CheckVolume) ValidateParams(params []string) ([]string, error)

func (*CheckVolume) Validate_State

func (cmd *CheckVolume) Validate_State() error

type CopyImage

type CopyImage struct {
	Name         *string `awsName:"Name" awsType:"awsstr" templateName:"name" required:""`
	SourceId     *string `awsName:"SourceImageId" awsType:"awsstr" templateName:"source-id" required:""`
	SourceRegion *string `awsName:"SourceRegion" awsType:"awsstr" templateName:"source-region" required:""`
	Encrypted    *bool   `awsName:"Encrypted" awsType:"awsbool" templateName:"encrypted"`
	Description  *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCopyImage

func NewCopyImage(sess *session.Session, l ...*logger.Logger) *CopyImage

func (*CopyImage) DryRun

func (cmd *CopyImage) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CopyImage) ExtractResult

func (cmd *CopyImage) ExtractResult(i interface{}) string

func (*CopyImage) ParamsHelp

func (cmd *CopyImage) ParamsHelp() string

func (*CopyImage) Run

func (cmd *CopyImage) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CopyImage) SetApi

func (cmd *CopyImage) SetApi(api ec2iface.EC2API)

func (*CopyImage) ValidateCommand

func (cmd *CopyImage) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CopyImage) ValidateParams

func (cmd *CopyImage) ValidateParams(params []string) ([]string, error)

type CopySnapshot

type CopySnapshot struct {
	SourceId     *string `awsName:"SourceSnapshotId" awsType:"awsstr" templateName:"source-id" required:""`
	SourceRegion *string `awsName:"SourceRegion" awsType:"awsstr" templateName:"source-region" required:""`
	Encrypted    *bool   `awsName:"Encrypted" awsType:"awsbool" templateName:"encrypted"`
	Description  *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCopySnapshot

func NewCopySnapshot(sess *session.Session, l ...*logger.Logger) *CopySnapshot

func (*CopySnapshot) DryRun

func (cmd *CopySnapshot) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CopySnapshot) ExtractResult

func (cmd *CopySnapshot) ExtractResult(i interface{}) string

func (*CopySnapshot) ParamsHelp

func (cmd *CopySnapshot) ParamsHelp() string

func (*CopySnapshot) Run

func (cmd *CopySnapshot) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CopySnapshot) SetApi

func (cmd *CopySnapshot) SetApi(api ec2iface.EC2API)

func (*CopySnapshot) ValidateCommand

func (cmd *CopySnapshot) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CopySnapshot) ValidateParams

func (cmd *CopySnapshot) ValidateParams(params []string) ([]string, error)

type CreateAccesskey

type CreateAccesskey struct {
	User     *string `awsName:"UserName" awsType:"awsstr" templateName:"user" required:""`
	NoPrompt *bool   `templateName:"no-prompt"`
	// contains filtered or unexported fields
}

func NewCreateAccesskey

func NewCreateAccesskey(sess *session.Session, l ...*logger.Logger) *CreateAccesskey

func (*CreateAccesskey) AfterRun

func (cmd *CreateAccesskey) AfterRun(ctx map[string]interface{}, output interface{}) error

func (*CreateAccesskey) DryRun

func (cmd *CreateAccesskey) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAccesskey) ExtractResult

func (cmd *CreateAccesskey) ExtractResult(i interface{}) string

func (*CreateAccesskey) ParamsHelp

func (cmd *CreateAccesskey) ParamsHelp() string

func (*CreateAccesskey) Run

func (cmd *CreateAccesskey) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAccesskey) SetApi

func (cmd *CreateAccesskey) SetApi(api iamiface.IAMAPI)

func (*CreateAccesskey) ValidateCommand

func (cmd *CreateAccesskey) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateAccesskey) ValidateParams

func (cmd *CreateAccesskey) ValidateParams(params []string) ([]string, error)

type CreateAlarm

type CreateAlarm struct {
	Name                    *string   `awsName:"AlarmName" awsType:"awsstr" templateName:"name" required:""`
	Operator                *string   `awsName:"ComparisonOperator" awsType:"awsstr" templateName:"operator" required:""`
	Metric                  *string   `awsName:"MetricName" awsType:"awsstr" templateName:"metric" required:""`
	Namespace               *string   `awsName:"Namespace" awsType:"awsstr" templateName:"namespace" required:""`
	EvaluationPeriods       *int64    `awsName:"EvaluationPeriods" awsType:"awsint64" templateName:"evaluation-periods" required:""`
	Period                  *int64    `awsName:"Period" awsType:"awsint64" templateName:"period" required:""`
	StatisticFunction       *string   `awsName:"Statistic" awsType:"awsstr" templateName:"statistic-function" required:""`
	Threshold               *float64  `awsName:"Threshold" awsType:"awsfloat" templateName:"threshold" required:""`
	Enabled                 *bool     `awsName:"ActionsEnabled" awsType:"awsbool" templateName:"enabled"`
	AlarmActions            []*string `awsName:"AlarmActions" awsType:"awsstringslice" templateName:"alarm-actions"`
	InsufficientdataActions []*string `awsName:"InsufficientDataActions" awsType:"awsstringslice" templateName:"insufficientdata-actions"`
	OkActions               []*string `awsName:"OKActions" awsType:"awsstringslice" templateName:"ok-actions"`
	Description             *string   `awsName:"AlarmDescription" awsType:"awsstr" templateName:"description"`
	Dimensions              []*string `awsName:"Dimensions" awsType:"awsdimensionslice" templateName:"dimensions"`
	Unit                    *string   `awsName:"Unit" awsType:"awsstr" templateName:"unit"`
	// contains filtered or unexported fields
}

func NewCreateAlarm

func NewCreateAlarm(sess *session.Session, l ...*logger.Logger) *CreateAlarm

func (*CreateAlarm) DryRun

func (cmd *CreateAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAlarm) ExtractResult

func (cmd *CreateAlarm) ExtractResult(i interface{}) string

func (*CreateAlarm) ParamsHelp

func (cmd *CreateAlarm) ParamsHelp() string

func (*CreateAlarm) Run

func (cmd *CreateAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAlarm) SetApi

func (cmd *CreateAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*CreateAlarm) ValidateCommand

func (cmd *CreateAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateAlarm) ValidateParams

func (cmd *CreateAlarm) ValidateParams(params []string) ([]string, error)

func (*CreateAlarm) Validate_Operator

func (cmd *CreateAlarm) Validate_Operator() error

type CreateAppscalingpolicy

type CreateAppscalingpolicy struct {
	Name                              *string   `awsName:"PolicyName" awsType:"awsstr" templateName:"name" required:""`
	Type                              *string   `awsName:"PolicyType" awsType:"awsstr" templateName:"type" required:""`
	Resource                          *string   `awsName:"ResourceId" awsType:"awsstr" templateName:"resource" required:""`
	Dimension                         *string   `awsName:"ScalableDimension" awsType:"awsstr" templateName:"dimension" required:""`
	ServiceNamespace                  *string   `awsName:"ServiceNamespace" awsType:"awsstr" templateName:"service-namespace" required:""`
	StepscalingAdjustmentType         *string   `` /* 127-byte string literal not displayed */
	StepscalingAdjustments            []*string `` /* 136-byte string literal not displayed */
	StepscalingCooldown               *int64    `awsName:"StepScalingPolicyConfiguration.Cooldown" awsType:"awsint64" templateName:"stepscaling-cooldown"`
	StepscalingAggregationType        *string   `awsName:"StepScalingPolicyConfiguration.MetricAggregationType" awsType:"awsstr" templateName:"stepscaling-aggregation-type"`
	StepscalingMinAdjustmentMagnitude *int64    `` /* 134-byte string literal not displayed */
	// contains filtered or unexported fields
}

func NewCreateAppscalingpolicy

func NewCreateAppscalingpolicy(sess *session.Session, l ...*logger.Logger) *CreateAppscalingpolicy

func (*CreateAppscalingpolicy) DryRun

func (cmd *CreateAppscalingpolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAppscalingpolicy) ExtractResult

func (cmd *CreateAppscalingpolicy) ExtractResult(i interface{}) string

func (*CreateAppscalingpolicy) ParamsHelp

func (cmd *CreateAppscalingpolicy) ParamsHelp() string

func (*CreateAppscalingpolicy) Run

func (cmd *CreateAppscalingpolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAppscalingpolicy) SetApi

func (*CreateAppscalingpolicy) ValidateCommand

func (cmd *CreateAppscalingpolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateAppscalingpolicy) ValidateParams

func (cmd *CreateAppscalingpolicy) ValidateParams(params []string) ([]string, error)

type CreateAppscalingtarget

type CreateAppscalingtarget struct {
	MaxCapacity      *int64  `awsName:"MaxCapacity" awsType:"awsint64" templateName:"max-capacity" required:""`
	MinCapacity      *int64  `awsName:"MinCapacity" awsType:"awsint64" templateName:"min-capacity" required:""`
	Resource         *string `awsName:"ResourceId" awsType:"awsstr" templateName:"resource" required:""`
	Role             *string `awsName:"RoleARN" awsType:"awsstr" templateName:"role" required:""`
	Dimension        *string `awsName:"ScalableDimension" awsType:"awsstr" templateName:"dimension" required:""`
	ServiceNamespace *string `awsName:"ServiceNamespace" awsType:"awsstr" templateName:"service-namespace" required:""`
	// contains filtered or unexported fields
}

func NewCreateAppscalingtarget

func NewCreateAppscalingtarget(sess *session.Session, l ...*logger.Logger) *CreateAppscalingtarget

func (*CreateAppscalingtarget) DryRun

func (cmd *CreateAppscalingtarget) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAppscalingtarget) ParamsHelp

func (cmd *CreateAppscalingtarget) ParamsHelp() string

func (*CreateAppscalingtarget) Run

func (cmd *CreateAppscalingtarget) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateAppscalingtarget) SetApi

func (*CreateAppscalingtarget) ValidateCommand

func (cmd *CreateAppscalingtarget) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateAppscalingtarget) ValidateParams

func (cmd *CreateAppscalingtarget) ValidateParams(params []string) ([]string, error)

type CreateBucket

type CreateBucket struct {
	Name *string `awsName:"Bucket" awsType:"awsstr" templateName:"name" required:""`
	Acl  *string `awsName:"ACL" awsType:"awsstr" templateName:"acl"`
	// contains filtered or unexported fields
}

func NewCreateBucket

func NewCreateBucket(sess *session.Session, l ...*logger.Logger) *CreateBucket

func (*CreateBucket) DryRun

func (cmd *CreateBucket) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateBucket) ExtractResult

func (cmd *CreateBucket) ExtractResult(i interface{}) string

func (*CreateBucket) ParamsHelp

func (cmd *CreateBucket) ParamsHelp() string

func (*CreateBucket) Run

func (cmd *CreateBucket) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateBucket) SetApi

func (cmd *CreateBucket) SetApi(api s3iface.S3API)

func (*CreateBucket) ValidateCommand

func (cmd *CreateBucket) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateBucket) ValidateParams

func (cmd *CreateBucket) ValidateParams(params []string) ([]string, error)

type CreateCertificate

type CreateCertificate struct {
	Domains           []*string `templateName:"domains" required:""`
	ValidationDomains []*string `templateName:"validation-domains"`
	// contains filtered or unexported fields
}

func NewCreateCertificate

func NewCreateCertificate(sess *session.Session, l ...*logger.Logger) *CreateCertificate

func (*CreateCertificate) DryRun

func (cmd *CreateCertificate) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateCertificate) ExtractResult

func (cmd *CreateCertificate) ExtractResult(i interface{}) string

func (*CreateCertificate) ManualRun

func (cmd *CreateCertificate) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CreateCertificate) ParamsHelp

func (cmd *CreateCertificate) ParamsHelp() string

func (*CreateCertificate) Run

func (cmd *CreateCertificate) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateCertificate) SetApi

func (cmd *CreateCertificate) SetApi(api acmiface.ACMAPI)

func (*CreateCertificate) ValidateCommand

func (cmd *CreateCertificate) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateCertificate) ValidateParams

func (cmd *CreateCertificate) ValidateParams(params []string) ([]string, error)

type CreateContainercluster

type CreateContainercluster struct {
	Name *string `awsName:"ClusterName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewCreateContainercluster

func NewCreateContainercluster(sess *session.Session, l ...*logger.Logger) *CreateContainercluster

func (*CreateContainercluster) DryRun

func (cmd *CreateContainercluster) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateContainercluster) ExtractResult

func (cmd *CreateContainercluster) ExtractResult(i interface{}) string

func (*CreateContainercluster) ParamsHelp

func (cmd *CreateContainercluster) ParamsHelp() string

func (*CreateContainercluster) Run

func (cmd *CreateContainercluster) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateContainercluster) SetApi

func (cmd *CreateContainercluster) SetApi(api ecsiface.ECSAPI)

func (*CreateContainercluster) ValidateCommand

func (cmd *CreateContainercluster) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateContainercluster) ValidateParams

func (cmd *CreateContainercluster) ValidateParams(params []string) ([]string, error)

type CreateDatabase

type CreateDatabase struct {
	Type              *string   `awsName:"DBInstanceClass" awsType:"awsstr" templateName:"type" required:""`
	Id                *string   `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"id" required:""`
	Engine            *string   `awsName:"Engine" awsType:"awsstr" templateName:"engine" required:""`
	Password          *string   `awsName:"MasterUserPassword" awsType:"awsstr" templateName:"password" required:""`
	Username          *string   `awsName:"MasterUsername" awsType:"awsstr" templateName:"username" required:""`
	Size              *int64    `awsName:"AllocatedStorage" awsType:"awsint64" templateName:"size" required:""`
	Autoupgrade       *bool     `awsName:"AutoMinorVersionUpgrade" awsType:"awsbool" templateName:"autoupgrade"`
	Availabilityzone  *string   `awsName:"AvailabilityZone" awsType:"awsstr" templateName:"availabilityzone"`
	Backupretention   *int64    `awsName:"BackupRetentionPeriod" awsType:"awsint64" templateName:"backupretention"`
	Cluster           *string   `awsName:"DBClusterIdentifier" awsType:"awsstr" templateName:"cluster"`
	Dbname            *string   `awsName:"DBName" awsType:"awsstr" templateName:"dbname"`
	Parametergroup    *string   `awsName:"DBParameterGroupName" awsType:"awsstr" templateName:"parametergroup"`
	Dbsecuritygroups  []*string `awsName:"DBSecurityGroups" awsType:"awsstringslice" templateName:"dbsecuritygroups"`
	Subnetgroup       *string   `awsName:"DBSubnetGroupName" awsType:"awsstr" templateName:"subnetgroup"`
	Domain            *string   `awsName:"Domain" awsType:"awsstr" templateName:"domain"`
	Iamrole           *string   `awsName:"DomainIAMRoleName" awsType:"awsstr" templateName:"iamrole"`
	Version           *string   `awsName:"EngineVersion" awsType:"awsstr" templateName:"version"`
	Iops              *int64    `awsName:"Iops" awsType:"awsint64" templateName:"iops"`
	License           *string   `awsName:"LicenseModel" awsType:"awsstr" templateName:"license"`
	Multiaz           *bool     `awsName:"MultiAZ" awsType:"awsbool" templateName:"multiaz"`
	Optiongroup       *string   `awsName:"OptionGroupName" awsType:"awsstr" templateName:"optiongroup"`
	Port              *int64    `awsName:"Port" awsType:"awsint64" templateName:"port"`
	Backupwindow      *string   `awsName:"PreferredBackupWindow" awsType:"awsstr" templateName:"backupwindow"`
	Maintenancewindow *string   `awsName:"PreferredMaintenanceWindow" awsType:"awsstr" templateName:"maintenancewindow"`
	Public            *bool     `awsName:"PubliclyAccessible" awsType:"awsbool" templateName:"public"`
	Encrypted         *bool     `awsName:"StorageEncrypted" awsType:"awsbool" templateName:"encrypted"`
	Storagetype       *string   `awsName:"StorageType" awsType:"awsstr" templateName:"storagetype"`
	Timezone          *string   `awsName:"Timezone" awsType:"awsstr" templateName:"timezone"`
	Vpcsecuritygroups []*string `awsName:"VpcSecurityGroupIds" awsType:"awsstringslice" templateName:"vpcsecuritygroups"`
	// contains filtered or unexported fields
}

func NewCreateDatabase

func NewCreateDatabase(sess *session.Session, l ...*logger.Logger) *CreateDatabase

func (*CreateDatabase) DryRun

func (cmd *CreateDatabase) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateDatabase) ExtractResult

func (cmd *CreateDatabase) ExtractResult(i interface{}) string

func (*CreateDatabase) ParamsHelp

func (cmd *CreateDatabase) ParamsHelp() string

func (*CreateDatabase) Run

func (cmd *CreateDatabase) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateDatabase) SetApi

func (cmd *CreateDatabase) SetApi(api rdsiface.RDSAPI)

func (*CreateDatabase) ValidateCommand

func (cmd *CreateDatabase) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateDatabase) ValidateParams

func (cmd *CreateDatabase) ValidateParams(params []string) ([]string, error)

type CreateDbsubnetgroup

type CreateDbsubnetgroup struct {
	Name        *string   `awsName:"DBSubnetGroupName" awsType:"awsstr" templateName:"name" required:""`
	Description *string   `awsName:"DBSubnetGroupDescription" awsType:"awsstr" templateName:"description" required:""`
	Subnets     []*string `awsName:"SubnetIds" awsType:"awsstringslice" templateName:"subnets" required:""`
	// contains filtered or unexported fields
}

func NewCreateDbsubnetgroup

func NewCreateDbsubnetgroup(sess *session.Session, l ...*logger.Logger) *CreateDbsubnetgroup

func (*CreateDbsubnetgroup) DryRun

func (cmd *CreateDbsubnetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateDbsubnetgroup) ExtractResult

func (cmd *CreateDbsubnetgroup) ExtractResult(i interface{}) string

func (*CreateDbsubnetgroup) ParamsHelp

func (cmd *CreateDbsubnetgroup) ParamsHelp() string

func (*CreateDbsubnetgroup) Run

func (cmd *CreateDbsubnetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateDbsubnetgroup) SetApi

func (cmd *CreateDbsubnetgroup) SetApi(api rdsiface.RDSAPI)

func (*CreateDbsubnetgroup) ValidateCommand

func (cmd *CreateDbsubnetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateDbsubnetgroup) ValidateParams

func (cmd *CreateDbsubnetgroup) ValidateParams(params []string) ([]string, error)

type CreateDistribution

type CreateDistribution struct {
	OriginDomain   *string   `templateName:"origin-domain" required:""`
	Certificate    *string   `templateName:"certificate"`
	Comment        *string   `templateName:"comment"`
	DefaultFile    *string   `templateName:"default-file"`
	DomainAliases  []*string `templateName:"domain-aliases"`
	Enable         *bool     `templateName:"enable"`
	ForwardCookies *string   `templateName:"forward-cookies"`
	ForwardQueries *bool     `templateName:"forward-queries"`
	HttpsBehaviour *string   `templateName:"https-behaviour"`
	OriginPath     *string   `templateName:"origin-path"`
	PriceClass     *string   `templateName:"price-class"`
	MinTtl         *int64    `templateName:"min-ttl"`
	// contains filtered or unexported fields
}

func NewCreateDistribution

func NewCreateDistribution(sess *session.Session, l ...*logger.Logger) *CreateDistribution

func (*CreateDistribution) DryRun

func (cmd *CreateDistribution) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateDistribution) ExtractResult

func (cmd *CreateDistribution) ExtractResult(i interface{}) string

func (*CreateDistribution) ManualRun

func (cmd *CreateDistribution) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CreateDistribution) ParamsHelp

func (cmd *CreateDistribution) ParamsHelp() string

func (*CreateDistribution) Run

func (cmd *CreateDistribution) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateDistribution) SetApi

func (*CreateDistribution) ValidateCommand

func (cmd *CreateDistribution) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateDistribution) ValidateParams

func (cmd *CreateDistribution) ValidateParams(params []string) ([]string, error)

type CreateElasticip

type CreateElasticip struct {
	Domain *string `awsName:"Domain" awsType:"awsstr" templateName:"domain" required:""`
	// contains filtered or unexported fields
}

func NewCreateElasticip

func NewCreateElasticip(sess *session.Session, l ...*logger.Logger) *CreateElasticip

func (*CreateElasticip) DryRun

func (cmd *CreateElasticip) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateElasticip) ExtractResult

func (cmd *CreateElasticip) ExtractResult(i interface{}) string

func (*CreateElasticip) ParamsHelp

func (cmd *CreateElasticip) ParamsHelp() string

func (*CreateElasticip) Run

func (cmd *CreateElasticip) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateElasticip) SetApi

func (cmd *CreateElasticip) SetApi(api ec2iface.EC2API)

func (*CreateElasticip) ValidateCommand

func (cmd *CreateElasticip) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateElasticip) ValidateParams

func (cmd *CreateElasticip) ValidateParams(params []string) ([]string, error)

type CreateFunction

type CreateFunction struct {
	Name          *string `awsName:"FunctionName" awsType:"awsstr" templateName:"name" required:""`
	Handler       *string `awsName:"Handler" awsType:"awsstr" templateName:"handler" required:""`
	Role          *string `awsName:"Role" awsType:"awsstr" templateName:"role" required:""`
	Runtime       *string `awsName:"Runtime" awsType:"awsstr" templateName:"runtime" required:""`
	Bucket        *string `awsName:"Code.S3Bucket" awsType:"awsstr" templateName:"bucket"`
	Object        *string `awsName:"Code.S3Key" awsType:"awsstr" templateName:"object"`
	Objectversion *string `awsName:"Code.S3ObjectVersion" awsType:"awsstr" templateName:"objectversion"`
	Zipfile       *string `awsName:"Code.ZipFile" awsType:"awsfiletobyteslice" templateName:"zipfile"`
	Description   *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	Memory        *int64  `awsName:"MemorySize" awsType:"awsint64" templateName:"memory"`
	Publish       *bool   `awsName:"Publish" awsType:"awsbool" templateName:"publish"`
	Timeout       *int64  `awsName:"Timeout" awsType:"awsint64" templateName:"timeout"`
	// contains filtered or unexported fields
}

func NewCreateFunction

func NewCreateFunction(sess *session.Session, l ...*logger.Logger) *CreateFunction

func (*CreateFunction) DryRun

func (cmd *CreateFunction) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateFunction) ExtractResult

func (cmd *CreateFunction) ExtractResult(i interface{}) string

func (*CreateFunction) ParamsHelp

func (cmd *CreateFunction) ParamsHelp() string

func (*CreateFunction) Run

func (cmd *CreateFunction) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateFunction) SetApi

func (cmd *CreateFunction) SetApi(api lambdaiface.LambdaAPI)

func (*CreateFunction) ValidateCommand

func (cmd *CreateFunction) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateFunction) ValidateParams

func (cmd *CreateFunction) ValidateParams(params []string) ([]string, error)

type CreateGroup

type CreateGroup struct {
	Name *string `awsName:"GroupName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewCreateGroup

func NewCreateGroup(sess *session.Session, l ...*logger.Logger) *CreateGroup

func (*CreateGroup) DryRun

func (cmd *CreateGroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateGroup) ExtractResult

func (cmd *CreateGroup) ExtractResult(i interface{}) string

func (*CreateGroup) ParamsHelp

func (cmd *CreateGroup) ParamsHelp() string

func (*CreateGroup) Run

func (cmd *CreateGroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateGroup) SetApi

func (cmd *CreateGroup) SetApi(api iamiface.IAMAPI)

func (*CreateGroup) ValidateCommand

func (cmd *CreateGroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateGroup) ValidateParams

func (cmd *CreateGroup) ValidateParams(params []string) ([]string, error)

type CreateInstance

type CreateInstance struct {
	Image          *string   `awsName:"ImageId" awsType:"awsstr" templateName:"image" required:""`
	Count          *int64    `awsName:"MaxCount,MinCount" awsType:"awsin64" templateName:"count" required:""`
	Type           *string   `awsName:"InstanceType" awsType:"awsstr" templateName:"type" required:""`
	Name           *string   `templateName:"name" required:""`
	Subnet         *string   `awsName:"SubnetId" awsType:"awsstr" templateName:"subnet" required:""`
	Keypair        *string   `awsName:"KeyName" awsType:"awsstr" templateName:"keypair"`
	PrivateIP      *string   `awsName:"PrivateIpAddress" awsType:"awsstr" templateName:"ip"`
	UserData       *string   `awsName:"UserData" awsType:"awsfiletobase64" templateName:"userdata"`
	SecurityGroups []*string `awsName:"SecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroup"`
	Lock           *bool     `awsName:"DisableApiTermination" awsType:"awsbool" templateName:"lock"`
	Role           *string   `awsName:"IamInstanceProfile.Name" awsType:"awsstr" templateName:"role"`
	// contains filtered or unexported fields
}

func NewCreateInstance

func NewCreateInstance(sess *session.Session, l ...*logger.Logger) *CreateInstance

func (*CreateInstance) AfterRun

func (cmd *CreateInstance) AfterRun(ctx map[string]interface{}, output interface{}) error

func (*CreateInstance) DryRun

func (cmd *CreateInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateInstance) ExtractResult

func (cmd *CreateInstance) ExtractResult(i interface{}) string

func (*CreateInstance) ParamsHelp

func (cmd *CreateInstance) ParamsHelp() string

func (*CreateInstance) Run

func (cmd *CreateInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateInstance) SetApi

func (cmd *CreateInstance) SetApi(api ec2iface.EC2API)

func (*CreateInstance) ValidateCommand

func (cmd *CreateInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateInstance) ValidateParams

func (cmd *CreateInstance) ValidateParams(params []string) ([]string, error)

type CreateInstanceprofile

type CreateInstanceprofile struct {
	Name *string `awsName:"InstanceProfileName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewCreateInstanceprofile

func NewCreateInstanceprofile(sess *session.Session, l ...*logger.Logger) *CreateInstanceprofile

func (*CreateInstanceprofile) DryRun

func (cmd *CreateInstanceprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateInstanceprofile) ParamsHelp

func (cmd *CreateInstanceprofile) ParamsHelp() string

func (*CreateInstanceprofile) Run

func (cmd *CreateInstanceprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateInstanceprofile) SetApi

func (cmd *CreateInstanceprofile) SetApi(api iamiface.IAMAPI)

func (*CreateInstanceprofile) ValidateCommand

func (cmd *CreateInstanceprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateInstanceprofile) ValidateParams

func (cmd *CreateInstanceprofile) ValidateParams(params []string) ([]string, error)

type CreateInternetgateway

type CreateInternetgateway struct {
	// contains filtered or unexported fields
}

func NewCreateInternetgateway

func NewCreateInternetgateway(sess *session.Session, l ...*logger.Logger) *CreateInternetgateway

func (*CreateInternetgateway) DryRun

func (cmd *CreateInternetgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateInternetgateway) ExtractResult

func (cmd *CreateInternetgateway) ExtractResult(i interface{}) string

func (*CreateInternetgateway) ParamsHelp

func (cmd *CreateInternetgateway) ParamsHelp() string

func (*CreateInternetgateway) Run

func (cmd *CreateInternetgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateInternetgateway) SetApi

func (cmd *CreateInternetgateway) SetApi(api ec2iface.EC2API)

func (*CreateInternetgateway) ValidateCommand

func (cmd *CreateInternetgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateInternetgateway) ValidateParams

func (cmd *CreateInternetgateway) ValidateParams(params []string) ([]string, error)

type CreateKeypair

type CreateKeypair struct {
	Name              *string `awsName:"KeyName" awsType:"awsstr" templateName:"name" required:""`
	Encrypted         *bool   `templateName:"encrypted"`
	PublicKeyMaterial []byte  `awsName:"PublicKeyMaterial" awsType:"awsbyteslice"`
	// contains filtered or unexported fields
}

func NewCreateKeypair

func NewCreateKeypair(sess *session.Session, l ...*logger.Logger) *CreateKeypair

func (*CreateKeypair) BeforeRun

func (cmd *CreateKeypair) BeforeRun(ctx map[string]interface{}) error

func (*CreateKeypair) DryRun

func (cmd *CreateKeypair) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateKeypair) ExtractResult

func (cmd *CreateKeypair) ExtractResult(i interface{}) string

func (*CreateKeypair) ParamsHelp

func (cmd *CreateKeypair) ParamsHelp() string

func (*CreateKeypair) Run

func (cmd *CreateKeypair) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateKeypair) SetApi

func (cmd *CreateKeypair) SetApi(api ec2iface.EC2API)

func (*CreateKeypair) ValidateCommand

func (cmd *CreateKeypair) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateKeypair) ValidateParams

func (cmd *CreateKeypair) ValidateParams(params []string) ([]string, error)

func (*CreateKeypair) Validate_Name

func (cmd *CreateKeypair) Validate_Name() error

type CreateLaunchconfiguration

type CreateLaunchconfiguration struct {
	Image          *string   `awsName:"ImageId" awsType:"awsstr" templateName:"image" required:""`
	Type           *string   `awsName:"InstanceType" awsType:"awsstr" templateName:"type" required:""`
	Name           *string   `awsName:"LaunchConfigurationName" awsType:"awsstr" templateName:"name" required:""`
	Public         *bool     `awsName:"AssociatePublicIpAddress" awsType:"awsbool" templateName:"public"`
	Keypair        *string   `awsName:"KeyName" awsType:"awsstr" templateName:"keypair"`
	Userdata       *string   `awsName:"UserData" awsType:"awsfiletobase64" templateName:"userdata"`
	Securitygroups []*string `awsName:"SecurityGroups" awsType:"awsstringslice" templateName:"securitygroups"`
	Role           *string   `awsName:"IamInstanceProfile" awsType:"awsstr" templateName:"role"`
	Spotprice      *string   `awsName:"SpotPrice" awsType:"awsstr" templateName:"spotprice"`
	// contains filtered or unexported fields
}

func NewCreateLaunchconfiguration

func NewCreateLaunchconfiguration(sess *session.Session, l ...*logger.Logger) *CreateLaunchconfiguration

func (*CreateLaunchconfiguration) DryRun

func (cmd *CreateLaunchconfiguration) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateLaunchconfiguration) ExtractResult

func (cmd *CreateLaunchconfiguration) ExtractResult(i interface{}) string

func (*CreateLaunchconfiguration) ParamsHelp

func (cmd *CreateLaunchconfiguration) ParamsHelp() string

func (*CreateLaunchconfiguration) Run

func (cmd *CreateLaunchconfiguration) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateLaunchconfiguration) SetApi

func (*CreateLaunchconfiguration) ValidateCommand

func (cmd *CreateLaunchconfiguration) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateLaunchconfiguration) ValidateParams

func (cmd *CreateLaunchconfiguration) ValidateParams(params []string) ([]string, error)

type CreateListener

type CreateListener struct {
	Actiontype   *string `awsName:"DefaultActions[0]Type" awsType:"awsslicestruct" templateName:"actiontype" required:""`
	Targetgroup  *string `awsName:"DefaultActions[0]TargetGroupArn" awsType:"awsslicestruct" templateName:"targetgroup" required:""`
	Loadbalancer *string `awsName:"LoadBalancerArn" awsType:"awsstr" templateName:"loadbalancer" required:""`
	Port         *int64  `awsName:"Port" awsType:"awsint64" templateName:"port" required:""`
	Protocol     *string `awsName:"Protocol" awsType:"awsstr" templateName:"protocol" required:""`
	Certificate  *string `awsName:"Certificates[0]CertificateArn" awsType:"awsslicestruct" templateName:"certificate"`
	Sslpolicy    *string `awsName:"SslPolicy" awsType:"awsstr" templateName:"sslpolicy"`
	// contains filtered or unexported fields
}

func NewCreateListener

func NewCreateListener(sess *session.Session, l ...*logger.Logger) *CreateListener

func (*CreateListener) DryRun

func (cmd *CreateListener) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateListener) ExtractResult

func (cmd *CreateListener) ExtractResult(i interface{}) string

func (*CreateListener) ParamsHelp

func (cmd *CreateListener) ParamsHelp() string

func (*CreateListener) Run

func (cmd *CreateListener) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateListener) SetApi

func (cmd *CreateListener) SetApi(api elbv2iface.ELBV2API)

func (*CreateListener) ValidateCommand

func (cmd *CreateListener) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateListener) ValidateParams

func (cmd *CreateListener) ValidateParams(params []string) ([]string, error)

type CreateLoadbalancer

type CreateLoadbalancer struct {
	Name           *string   `awsName:"Name" awsType:"awsstr" templateName:"name" required:""`
	Subnets        []*string `awsName:"Subnets" awsType:"awsstringslice" templateName:"subnets" required:""`
	SubnetMappings []*string `awsName:"SubnetMappings" awsType:"awssubnetmappings" templateName:"subnet-mappings"`
	Iptype         *string   `awsName:"IpAddressType" awsType:"awsstr" templateName:"iptype"`
	Scheme         *string   `awsName:"Scheme" awsType:"awsstr" templateName:"scheme"`
	Securitygroups []*string `awsName:"SecurityGroups" awsType:"awsstringslice" templateName:"securitygroups"`
	Type           *string   `awsName:"Type" awsType:"awsstr" templateName:"type"`
	// contains filtered or unexported fields
}

func NewCreateLoadbalancer

func NewCreateLoadbalancer(sess *session.Session, l ...*logger.Logger) *CreateLoadbalancer

func (*CreateLoadbalancer) DryRun

func (cmd *CreateLoadbalancer) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateLoadbalancer) ExtractResult

func (cmd *CreateLoadbalancer) ExtractResult(i interface{}) string

func (*CreateLoadbalancer) ParamsHelp

func (cmd *CreateLoadbalancer) ParamsHelp() string

func (*CreateLoadbalancer) Run

func (cmd *CreateLoadbalancer) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateLoadbalancer) SetApi

func (cmd *CreateLoadbalancer) SetApi(api elbv2iface.ELBV2API)

func (*CreateLoadbalancer) ValidateCommand

func (cmd *CreateLoadbalancer) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateLoadbalancer) ValidateParams

func (cmd *CreateLoadbalancer) ValidateParams(params []string) ([]string, error)

type CreateLoginprofile

type CreateLoginprofile struct {
	Username      *string `awsName:"UserName" awsType:"awsstr" templateName:"username" required:""`
	Password      *string `awsName:"Password" awsType:"awsstr" templateName:"password" required:""`
	PasswordReset *bool   `awsName:"PasswordResetRequired" awsType:"awsbool" templateName:"password-reset"`
	// contains filtered or unexported fields
}

func NewCreateLoginprofile

func NewCreateLoginprofile(sess *session.Session, l ...*logger.Logger) *CreateLoginprofile

func (*CreateLoginprofile) DryRun

func (cmd *CreateLoginprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateLoginprofile) ExtractResult

func (cmd *CreateLoginprofile) ExtractResult(i interface{}) string

func (*CreateLoginprofile) ParamsHelp

func (cmd *CreateLoginprofile) ParamsHelp() string

func (*CreateLoginprofile) Run

func (cmd *CreateLoginprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateLoginprofile) SetApi

func (cmd *CreateLoginprofile) SetApi(api iamiface.IAMAPI)

func (*CreateLoginprofile) ValidateCommand

func (cmd *CreateLoginprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateLoginprofile) ValidateParams

func (cmd *CreateLoginprofile) ValidateParams(params []string) ([]string, error)

type CreateMfadevice

type CreateMfadevice struct {
	Name *string `templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewCreateMfadevice

func NewCreateMfadevice(sess *session.Session, l ...*logger.Logger) *CreateMfadevice

func (*CreateMfadevice) DryRun

func (cmd *CreateMfadevice) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateMfadevice) ExtractResult

func (cmd *CreateMfadevice) ExtractResult(i interface{}) string

func (*CreateMfadevice) ManualRun

func (cmd *CreateMfadevice) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CreateMfadevice) ParamsHelp

func (cmd *CreateMfadevice) ParamsHelp() string

func (*CreateMfadevice) Run

func (cmd *CreateMfadevice) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateMfadevice) SetApi

func (cmd *CreateMfadevice) SetApi(api iamiface.IAMAPI)

func (*CreateMfadevice) ValidateCommand

func (cmd *CreateMfadevice) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateMfadevice) ValidateParams

func (cmd *CreateMfadevice) ValidateParams(params []string) ([]string, error)

type CreateNatgateway

type CreateNatgateway struct {
	ElasticipId *string `awsName:"AllocationId" awsType:"awsstr" templateName:"elasticip-id" required:""`
	Subnet      *string `awsName:"SubnetId" awsType:"awsstr" templateName:"subnet" required:""`
	// contains filtered or unexported fields
}

func NewCreateNatgateway

func NewCreateNatgateway(sess *session.Session, l ...*logger.Logger) *CreateNatgateway

func (*CreateNatgateway) DryRun

func (cmd *CreateNatgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateNatgateway) ExtractResult

func (cmd *CreateNatgateway) ExtractResult(i interface{}) string

func (*CreateNatgateway) ParamsHelp

func (cmd *CreateNatgateway) ParamsHelp() string

func (*CreateNatgateway) Run

func (cmd *CreateNatgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateNatgateway) SetApi

func (cmd *CreateNatgateway) SetApi(api ec2iface.EC2API)

func (*CreateNatgateway) ValidateCommand

func (cmd *CreateNatgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateNatgateway) ValidateParams

func (cmd *CreateNatgateway) ValidateParams(params []string) ([]string, error)

type CreateNetworkinterface

type CreateNetworkinterface struct {
	Subnet         *string   `awsName:"SubnetId" awsType:"awsstr" templateName:"subnet" required:""`
	Description    *string   `awsName:"Description" awsType:"awsstr" templateName:"description"`
	Securitygroups []*string `awsName:"Groups" awsType:"awsstringslice" templateName:"securitygroups"`
	Privateip      *string   `awsName:"PrivateIpAddress" awsType:"awsstr" templateName:"privateip"`
	// contains filtered or unexported fields
}

func NewCreateNetworkinterface

func NewCreateNetworkinterface(sess *session.Session, l ...*logger.Logger) *CreateNetworkinterface

func (*CreateNetworkinterface) DryRun

func (cmd *CreateNetworkinterface) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateNetworkinterface) ExtractResult

func (cmd *CreateNetworkinterface) ExtractResult(i interface{}) string

func (*CreateNetworkinterface) ParamsHelp

func (cmd *CreateNetworkinterface) ParamsHelp() string

func (*CreateNetworkinterface) Run

func (cmd *CreateNetworkinterface) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateNetworkinterface) SetApi

func (cmd *CreateNetworkinterface) SetApi(api ec2iface.EC2API)

func (*CreateNetworkinterface) ValidateCommand

func (cmd *CreateNetworkinterface) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateNetworkinterface) ValidateParams

func (cmd *CreateNetworkinterface) ValidateParams(params []string) ([]string, error)

type CreatePolicy

type CreatePolicy struct {
	Name        *string   `awsName:"PolicyName" awsType:"awsstr" templateName:"name" required:""`
	Effect      *string   `templateName:"effect" required:""`
	Action      []*string `templateName:"action" required:""`
	Resource    []*string `templateName:"resource" required:""`
	Description *string   `awsName:"Description" awsType:"awsstr" templateName:"description"`
	Document    *string   `awsName:"PolicyDocument" awsType:"awsstr"`
	Conditions  []*string `templateName:"conditions"`
	// contains filtered or unexported fields
}

func NewCreatePolicy

func NewCreatePolicy(sess *session.Session, l ...*logger.Logger) *CreatePolicy

func (*CreatePolicy) BeforeRun

func (cmd *CreatePolicy) BeforeRun(ctx map[string]interface{}) error

func (*CreatePolicy) DryRun

func (cmd *CreatePolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreatePolicy) ExtractResult

func (cmd *CreatePolicy) ExtractResult(i interface{}) string

func (*CreatePolicy) ParamsHelp

func (cmd *CreatePolicy) ParamsHelp() string

func (*CreatePolicy) Run

func (cmd *CreatePolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreatePolicy) SetApi

func (cmd *CreatePolicy) SetApi(api iamiface.IAMAPI)

func (*CreatePolicy) ValidateCommand

func (cmd *CreatePolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreatePolicy) ValidateParams

func (cmd *CreatePolicy) ValidateParams(params []string) ([]string, error)

type CreateQueue

type CreateQueue struct {
	Name              *string `awsName:"QueueName" awsType:"awsstr" templateName:"name" required:""`
	Delay             *string `awsName:"Attributes[DelaySeconds]" awsType:"awsstringpointermap" templateName:"delay"`
	MaxMsgSize        *string `awsName:"Attributes[MaximumMessageSize]" awsType:"awsstringpointermap" templateName:"max-msg-size"`
	RetentionPeriod   *string `awsName:"Attributes[MessageRetentionPeriod]" awsType:"awsstringpointermap" templateName:"retention-period"`
	Policy            *string `awsName:"Attributes[Policy]" awsType:"awsstringpointermap" templateName:"policy"`
	MsgWait           *string `awsName:"Attributes[ReceiveMessageWaitTimeSeconds]" awsType:"awsstringpointermap" templateName:"msg-wait"`
	RedrivePolicy     *string `awsName:"Attributes[RedrivePolicy]" awsType:"awsstringpointermap" templateName:"redrive-policy"`
	VisibilityTimeout *string `awsName:"Attributes[VisibilityTimeout]" awsType:"awsstringpointermap" templateName:"visibility-timeout"`
	// contains filtered or unexported fields
}

func NewCreateQueue

func NewCreateQueue(sess *session.Session, l ...*logger.Logger) *CreateQueue

func (*CreateQueue) DryRun

func (cmd *CreateQueue) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateQueue) ExtractResult

func (cmd *CreateQueue) ExtractResult(i interface{}) string

func (*CreateQueue) ParamsHelp

func (cmd *CreateQueue) ParamsHelp() string

func (*CreateQueue) Run

func (cmd *CreateQueue) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateQueue) SetApi

func (cmd *CreateQueue) SetApi(api sqsiface.SQSAPI)

func (*CreateQueue) ValidateCommand

func (cmd *CreateQueue) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateQueue) ValidateParams

func (cmd *CreateQueue) ValidateParams(params []string) ([]string, error)

type CreateRecord

type CreateRecord struct {
	Zone    *string `templateName:"zone" required:""`
	Name    *string `templateName:"name" required:""`
	Type    *string `templateName:"type" required:""`
	Value   *string `templateName:"value" required:""`
	Ttl     *int64  `templateName:"ttl" required:""`
	Comment *string `templateName:"comment"`
	// contains filtered or unexported fields
}

func NewCreateRecord

func NewCreateRecord(sess *session.Session, l ...*logger.Logger) *CreateRecord

func (*CreateRecord) DryRun

func (cmd *CreateRecord) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRecord) ExtractResult

func (cmd *CreateRecord) ExtractResult(i interface{}) string

func (*CreateRecord) ManualRun

func (cmd *CreateRecord) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CreateRecord) ParamsHelp

func (cmd *CreateRecord) ParamsHelp() string

func (*CreateRecord) Run

func (cmd *CreateRecord) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRecord) SetApi

func (cmd *CreateRecord) SetApi(api route53iface.Route53API)

func (*CreateRecord) ValidateCommand

func (cmd *CreateRecord) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateRecord) ValidateParams

func (cmd *CreateRecord) ValidateParams(params []string) ([]string, error)

type CreateRepository

type CreateRepository struct {
	Name *string `awsName:"RepositoryName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewCreateRepository

func NewCreateRepository(sess *session.Session, l ...*logger.Logger) *CreateRepository

func (*CreateRepository) DryRun

func (cmd *CreateRepository) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRepository) ExtractResult

func (cmd *CreateRepository) ExtractResult(i interface{}) string

func (*CreateRepository) ParamsHelp

func (cmd *CreateRepository) ParamsHelp() string

func (*CreateRepository) Run

func (cmd *CreateRepository) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRepository) SetApi

func (cmd *CreateRepository) SetApi(api ecriface.ECRAPI)

func (*CreateRepository) ValidateCommand

func (cmd *CreateRepository) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateRepository) ValidateParams

func (cmd *CreateRepository) ValidateParams(params []string) ([]string, error)

type CreateRole

type CreateRole struct {
	Name             *string   `awsName:"RoleName" awsType:"awsstr" templateName:"name" required:""`
	PrincipalAccount *string   `templateName:"principal-account"`
	PrincipalUser    *string   `templateName:"principal-user"`
	PrincipalService *string   `templateName:"principal-service"`
	Conditions       []*string `templateName:"conditions"`
	SleepAfter       *int64    `templateName:"sleep-after"`
	// contains filtered or unexported fields
}

func NewCreateRole

func NewCreateRole(sess *session.Session, l ...*logger.Logger) *CreateRole

func (*CreateRole) DryRun

func (cmd *CreateRole) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRole) ExtractResult

func (cmd *CreateRole) ExtractResult(i interface{}) string

func (*CreateRole) ManualRun

func (cmd *CreateRole) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CreateRole) ParamsHelp

func (cmd *CreateRole) ParamsHelp() string

func (*CreateRole) Run

func (cmd *CreateRole) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRole) SetApi

func (cmd *CreateRole) SetApi(api iamiface.IAMAPI)

func (*CreateRole) ValidateCommand

func (cmd *CreateRole) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateRole) ValidateParams

func (cmd *CreateRole) ValidateParams(params []string) ([]string, error)

type CreateRoute

type CreateRoute struct {
	Table   *string `awsName:"RouteTableId" awsType:"awsstr" templateName:"table" required:""`
	CIDR    *string `awsName:"DestinationCidrBlock" awsType:"awsstr" templateName:"cidr" required:""`
	Gateway *string `awsName:"GatewayId" awsType:"awsstr" templateName:"gateway" required:""`
	// contains filtered or unexported fields
}

func NewCreateRoute

func NewCreateRoute(sess *session.Session, l ...*logger.Logger) *CreateRoute

func (*CreateRoute) DryRun

func (cmd *CreateRoute) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRoute) ParamsHelp

func (cmd *CreateRoute) ParamsHelp() string

func (*CreateRoute) Run

func (cmd *CreateRoute) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRoute) SetApi

func (cmd *CreateRoute) SetApi(api ec2iface.EC2API)

func (*CreateRoute) ValidateCommand

func (cmd *CreateRoute) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateRoute) ValidateParams

func (cmd *CreateRoute) ValidateParams(params []string) ([]string, error)

func (*CreateRoute) Validate_CIDR

func (cmd *CreateRoute) Validate_CIDR() error

type CreateRoutetable

type CreateRoutetable struct {
	Vpc *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc" required:""`
	// contains filtered or unexported fields
}

func NewCreateRoutetable

func NewCreateRoutetable(sess *session.Session, l ...*logger.Logger) *CreateRoutetable

func (*CreateRoutetable) DryRun

func (cmd *CreateRoutetable) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRoutetable) ExtractResult

func (cmd *CreateRoutetable) ExtractResult(i interface{}) string

func (*CreateRoutetable) ParamsHelp

func (cmd *CreateRoutetable) ParamsHelp() string

func (*CreateRoutetable) Run

func (cmd *CreateRoutetable) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateRoutetable) SetApi

func (cmd *CreateRoutetable) SetApi(api ec2iface.EC2API)

func (*CreateRoutetable) ValidateCommand

func (cmd *CreateRoutetable) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateRoutetable) ValidateParams

func (cmd *CreateRoutetable) ValidateParams(params []string) ([]string, error)

type CreateS3object

type CreateS3object struct {
	Bucket *string `awsName:"Bucket" awsType:"awsstr" templateName:"bucket" required:""`
	File   *string `awsName:"Body" awsType:"awsstr" templateName:"file" required:""`
	Name   *string `awsName:"Key" awsType:"awsstr" templateName:"name"`
	Acl    *string `awsName:"ACL" awsType:"awsstr" templateName:"acl"`
	// contains filtered or unexported fields
}

func NewCreateS3object

func NewCreateS3object(sess *session.Session, l ...*logger.Logger) *CreateS3object

func (*CreateS3object) DryRun

func (cmd *CreateS3object) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateS3object) ExtractResult

func (cmd *CreateS3object) ExtractResult(i interface{}) string

func (*CreateS3object) ManualRun

func (cmd *CreateS3object) ManualRun(map[string]interface{}) (interface{}, error)

func (*CreateS3object) ParamsHelp

func (cmd *CreateS3object) ParamsHelp() string

func (*CreateS3object) Run

func (cmd *CreateS3object) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateS3object) SetApi

func (cmd *CreateS3object) SetApi(api s3iface.S3API)

func (*CreateS3object) ValidateCommand

func (cmd *CreateS3object) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateS3object) ValidateParams

func (cmd *CreateS3object) ValidateParams(params []string) ([]string, error)

func (*CreateS3object) Validate_File

func (cmd *CreateS3object) Validate_File() error

type CreateScalinggroup

type CreateScalinggroup struct {
	Name                   *string   `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name" required:""`
	Launchconfiguration    *string   `awsName:"LaunchConfigurationName" awsType:"awsstr" templateName:"launchconfiguration" required:""`
	MaxSize                *int64    `awsName:"MaxSize" awsType:"awsint64" templateName:"max-size" required:""`
	MinSize                *int64    `awsName:"MinSize" awsType:"awsint64" templateName:"min-size" required:""`
	Subnets                []*string `awsName:"VPCZoneIdentifier" awsType:"awscsvstr" templateName:"subnets" required:""`
	Cooldown               *int64    `awsName:"DefaultCooldown" awsType:"awsint64" templateName:"cooldown"`
	DesiredCapacity        *int64    `awsName:"DesiredCapacity" awsType:"awsint64" templateName:"desired-capacity"`
	HealthcheckGracePeriod *int64    `awsName:"HealthCheckGracePeriod" awsType:"awsint64" templateName:"healthcheck-grace-period"`
	HealthcheckType        *string   `awsName:"HealthCheckType" awsType:"awsstr" templateName:"healthcheck-type"`
	NewInstancesProtected  *bool     `awsName:"NewInstancesProtectedFromScaleIn" awsType:"awsbool" templateName:"new-instances-protected"`
	Targetgroups           []*string `awsName:"TargetGroupARNs" awsType:"awsstringslice" templateName:"targetgroups"`
	// contains filtered or unexported fields
}

func NewCreateScalinggroup

func NewCreateScalinggroup(sess *session.Session, l ...*logger.Logger) *CreateScalinggroup

func (*CreateScalinggroup) DryRun

func (cmd *CreateScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateScalinggroup) ExtractResult

func (cmd *CreateScalinggroup) ExtractResult(i interface{}) string

func (*CreateScalinggroup) ParamsHelp

func (cmd *CreateScalinggroup) ParamsHelp() string

func (*CreateScalinggroup) Run

func (cmd *CreateScalinggroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateScalinggroup) SetApi

func (*CreateScalinggroup) ValidateCommand

func (cmd *CreateScalinggroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateScalinggroup) ValidateParams

func (cmd *CreateScalinggroup) ValidateParams(params []string) ([]string, error)

type CreateScalingpolicy

type CreateScalingpolicy struct {
	AdjustmentType      *string `awsName:"AdjustmentType" awsType:"awsstr" templateName:"adjustment-type" required:""`
	Scalinggroup        *string `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"scalinggroup" required:""`
	Name                *string `awsName:"PolicyName" awsType:"awsstr" templateName:"name" required:""`
	AdjustmentScaling   *int64  `awsName:"ScalingAdjustment" awsType:"awsint64" templateName:"adjustment-scaling" required:""`
	Cooldown            *int64  `awsName:"Cooldown" awsType:"awsint64" templateName:"cooldown"`
	AdjustmentMagnitude *int64  `awsName:"MinAdjustmentMagnitude" awsType:"awsint64" templateName:"adjustment-magnitude"`
	// contains filtered or unexported fields
}

func NewCreateScalingpolicy

func NewCreateScalingpolicy(sess *session.Session, l ...*logger.Logger) *CreateScalingpolicy

func (*CreateScalingpolicy) DryRun

func (cmd *CreateScalingpolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateScalingpolicy) ExtractResult

func (cmd *CreateScalingpolicy) ExtractResult(i interface{}) string

func (*CreateScalingpolicy) ParamsHelp

func (cmd *CreateScalingpolicy) ParamsHelp() string

func (*CreateScalingpolicy) Run

func (cmd *CreateScalingpolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateScalingpolicy) SetApi

func (*CreateScalingpolicy) ValidateCommand

func (cmd *CreateScalingpolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateScalingpolicy) ValidateParams

func (cmd *CreateScalingpolicy) ValidateParams(params []string) ([]string, error)

type CreateSecuritygroup

type CreateSecuritygroup struct {
	Name        *string `awsName:"GroupName" awsType:"awsstr" templateName:"name" required:""`
	Vpc         *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc" required:""`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description" required:""`
	// contains filtered or unexported fields
}

func NewCreateSecuritygroup

func NewCreateSecuritygroup(sess *session.Session, l ...*logger.Logger) *CreateSecuritygroup

func (*CreateSecuritygroup) DryRun

func (cmd *CreateSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSecuritygroup) ExtractResult

func (cmd *CreateSecuritygroup) ExtractResult(i interface{}) string

func (*CreateSecuritygroup) ParamsHelp

func (cmd *CreateSecuritygroup) ParamsHelp() string

func (*CreateSecuritygroup) Run

func (cmd *CreateSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSecuritygroup) SetApi

func (cmd *CreateSecuritygroup) SetApi(api ec2iface.EC2API)

func (*CreateSecuritygroup) ValidateCommand

func (cmd *CreateSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateSecuritygroup) ValidateParams

func (cmd *CreateSecuritygroup) ValidateParams(params []string) ([]string, error)

type CreateSnapshot

type CreateSnapshot struct {
	Volume      *string `awsName:"VolumeId" awsType:"awsstr" templateName:"volume" required:""`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCreateSnapshot

func NewCreateSnapshot(sess *session.Session, l ...*logger.Logger) *CreateSnapshot

func (*CreateSnapshot) DryRun

func (cmd *CreateSnapshot) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSnapshot) ExtractResult

func (cmd *CreateSnapshot) ExtractResult(i interface{}) string

func (*CreateSnapshot) ParamsHelp

func (cmd *CreateSnapshot) ParamsHelp() string

func (*CreateSnapshot) Run

func (cmd *CreateSnapshot) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSnapshot) SetApi

func (cmd *CreateSnapshot) SetApi(api ec2iface.EC2API)

func (*CreateSnapshot) ValidateCommand

func (cmd *CreateSnapshot) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateSnapshot) ValidateParams

func (cmd *CreateSnapshot) ValidateParams(params []string) ([]string, error)

type CreateStack

type CreateStack struct {
	Name            *string   `awsName:"StackName" awsType:"awsstr" templateName:"name" required:""`
	TemplateFile    *string   `awsName:"TemplateBody" awsType:"awsfiletostring" templateName:"template-file" required:""`
	Capabilities    []*string `awsName:"Capabilities" awsType:"awsstringslice" templateName:"capabilities"`
	DisableRollback *bool     `awsName:"DisableRollback" awsType:"awsbool" templateName:"disable-rollback"`
	Notifications   []*string `awsName:"NotificationARNs" awsType:"awsstringslice" templateName:"notifications"`
	OnFailure       *string   `awsName:"OnFailure" awsType:"awsstr" templateName:"on-failure"`
	Parameters      []*string `awsName:"Parameters" awsType:"awsparameterslice" templateName:"parameters"`
	ResourceTypes   []*string `awsName:"ResourceTypes" awsType:"awsstringslice" templateName:"resource-types"`
	Role            *string   `awsName:"RoleARN" awsType:"awsstr" templateName:"role"`
	PolicyFile      *string   `awsName:"StackPolicyBody" awsType:"awsfiletostring" templateName:"policy-file"`
	Timeout         *int64    `awsName:"TimeoutInMinutes" awsType:"awsint64" templateName:"timeout"`
	// contains filtered or unexported fields
}

func NewCreateStack

func NewCreateStack(sess *session.Session, l ...*logger.Logger) *CreateStack

func (*CreateStack) DryRun

func (cmd *CreateStack) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateStack) ExtractResult

func (cmd *CreateStack) ExtractResult(i interface{}) string

func (*CreateStack) ParamsHelp

func (cmd *CreateStack) ParamsHelp() string

func (*CreateStack) Run

func (cmd *CreateStack) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateStack) SetApi

func (*CreateStack) ValidateCommand

func (cmd *CreateStack) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateStack) ValidateParams

func (cmd *CreateStack) ValidateParams(params []string) ([]string, error)

func (*CreateStack) Validate_TemplateFile

func (cmd *CreateStack) Validate_TemplateFile() error

type CreateSubnet

type CreateSubnet struct {
	CIDR             *string `awsName:"CidrBlock" awsType:"awsstr" templateName:"cidr" required:""`
	VPC              *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc" required:""`
	AvailabilityZone *string `awsName:"AvailabilityZone" awsType:"awsstr" templateName:"availabilityzone"`
	Name             *string `templateName:"name"`
	// contains filtered or unexported fields
}

func NewCreateSubnet

func NewCreateSubnet(sess *session.Session, l ...*logger.Logger) *CreateSubnet

func (*CreateSubnet) AfterRun

func (cmd *CreateSubnet) AfterRun(ctx map[string]interface{}, output interface{}) error

func (*CreateSubnet) DryRun

func (cmd *CreateSubnet) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSubnet) ExtractResult

func (cmd *CreateSubnet) ExtractResult(i interface{}) string

func (*CreateSubnet) ParamsHelp

func (cmd *CreateSubnet) ParamsHelp() string

func (*CreateSubnet) Run

func (cmd *CreateSubnet) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSubnet) SetApi

func (cmd *CreateSubnet) SetApi(api ec2iface.EC2API)

func (*CreateSubnet) ValidateCommand

func (cmd *CreateSubnet) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateSubnet) ValidateParams

func (cmd *CreateSubnet) ValidateParams(params []string) ([]string, error)

func (*CreateSubnet) Validate_CIDR

func (cmd *CreateSubnet) Validate_CIDR() error

type CreateSubscription

type CreateSubscription struct {
	Topic    *string `awsName:"TopicArn" awsType:"awsstr" templateName:"topic" required:""`
	Endpoint *string `awsName:"Endpoint" awsType:"awsstr" templateName:"endpoint" required:""`
	Protocol *string `awsName:"Protocol" awsType:"awsstr" templateName:"protocol" required:""`
	// contains filtered or unexported fields
}

func NewCreateSubscription

func NewCreateSubscription(sess *session.Session, l ...*logger.Logger) *CreateSubscription

func (*CreateSubscription) DryRun

func (cmd *CreateSubscription) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSubscription) ExtractResult

func (cmd *CreateSubscription) ExtractResult(i interface{}) string

func (*CreateSubscription) ParamsHelp

func (cmd *CreateSubscription) ParamsHelp() string

func (*CreateSubscription) Run

func (cmd *CreateSubscription) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateSubscription) SetApi

func (cmd *CreateSubscription) SetApi(api snsiface.SNSAPI)

func (*CreateSubscription) ValidateCommand

func (cmd *CreateSubscription) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateSubscription) ValidateParams

func (cmd *CreateSubscription) ValidateParams(params []string) ([]string, error)

type CreateTag

type CreateTag struct {
	Resource *string `awsName:"Resources" awsType:"awsstringslice" templateName:"resource" required:""`
	Key      *string `templateName:"key" required:""`
	Value    *string `templateName:"value" required:""`
	// contains filtered or unexported fields
}

func NewCreateTag

func NewCreateTag(sess *session.Session, l ...*logger.Logger) *CreateTag

func (*CreateTag) DryRun

func (cmd *CreateTag) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateTag) ManualRun

func (cmd *CreateTag) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*CreateTag) ParamsHelp

func (cmd *CreateTag) ParamsHelp() string

func (*CreateTag) Run

func (cmd *CreateTag) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateTag) SetApi

func (cmd *CreateTag) SetApi(api ec2iface.EC2API)

func (*CreateTag) ValidateCommand

func (cmd *CreateTag) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateTag) ValidateParams

func (cmd *CreateTag) ValidateParams(params []string) ([]string, error)

type CreateTargetgroup

type CreateTargetgroup struct {
	Name                *string `awsName:"Name" awsType:"awsstr" templateName:"name" required:""`
	Port                *int64  `awsName:"Port" awsType:"awsint64" templateName:"port" required:""`
	Protocol            *string `awsName:"Protocol" awsType:"awsstr" templateName:"protocol" required:""`
	Vpc                 *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc" required:""`
	Healthcheckinterval *int64  `awsName:"HealthCheckIntervalSeconds" awsType:"awsint64" templateName:"healthcheckinterval"`
	Healthcheckpath     *string `awsName:"HealthCheckPath" awsType:"awsstr" templateName:"healthcheckpath"`
	Healthcheckport     *string `awsName:"HealthCheckPort" awsType:"awsstr" templateName:"healthcheckport"`
	Healthcheckprotocol *string `awsName:"HealthCheckProtocol" awsType:"awsstr" templateName:"healthcheckprotocol"`
	Healthchecktimeout  *int64  `awsName:"HealthCheckTimeoutSeconds" awsType:"awsint64" templateName:"healthchecktimeout"`
	Healthythreshold    *int64  `awsName:"HealthyThresholdCount" awsType:"awsint64" templateName:"healthythreshold"`
	Unhealthythreshold  *int64  `awsName:"UnhealthyThresholdCount" awsType:"awsint64" templateName:"unhealthythreshold"`
	Matcher             *string `awsName:"Matcher.HttpCode" awsType:"awsstr" templateName:"matcher"`
	// contains filtered or unexported fields
}

func NewCreateTargetgroup

func NewCreateTargetgroup(sess *session.Session, l ...*logger.Logger) *CreateTargetgroup

func (*CreateTargetgroup) DryRun

func (cmd *CreateTargetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateTargetgroup) ExtractResult

func (cmd *CreateTargetgroup) ExtractResult(i interface{}) string

func (*CreateTargetgroup) ParamsHelp

func (cmd *CreateTargetgroup) ParamsHelp() string

func (*CreateTargetgroup) Run

func (cmd *CreateTargetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateTargetgroup) SetApi

func (cmd *CreateTargetgroup) SetApi(api elbv2iface.ELBV2API)

func (*CreateTargetgroup) ValidateCommand

func (cmd *CreateTargetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateTargetgroup) ValidateParams

func (cmd *CreateTargetgroup) ValidateParams(params []string) ([]string, error)

type CreateTopic

type CreateTopic struct {
	Name *string `awsName:"Name" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewCreateTopic

func NewCreateTopic(sess *session.Session, l ...*logger.Logger) *CreateTopic

func (*CreateTopic) DryRun

func (cmd *CreateTopic) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateTopic) ExtractResult

func (cmd *CreateTopic) ExtractResult(i interface{}) string

func (*CreateTopic) ParamsHelp

func (cmd *CreateTopic) ParamsHelp() string

func (*CreateTopic) Run

func (cmd *CreateTopic) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateTopic) SetApi

func (cmd *CreateTopic) SetApi(api snsiface.SNSAPI)

func (*CreateTopic) ValidateCommand

func (cmd *CreateTopic) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateTopic) ValidateParams

func (cmd *CreateTopic) ValidateParams(params []string) ([]string, error)

type CreateUser

type CreateUser struct {
	Name *string `awsName:"UserName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewCreateUser

func NewCreateUser(sess *session.Session, l ...*logger.Logger) *CreateUser

func (*CreateUser) DryRun

func (cmd *CreateUser) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateUser) ExtractResult

func (cmd *CreateUser) ExtractResult(i interface{}) string

func (*CreateUser) ParamsHelp

func (cmd *CreateUser) ParamsHelp() string

func (*CreateUser) Run

func (cmd *CreateUser) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateUser) SetApi

func (cmd *CreateUser) SetApi(api iamiface.IAMAPI)

func (*CreateUser) ValidateCommand

func (cmd *CreateUser) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateUser) ValidateParams

func (cmd *CreateUser) ValidateParams(params []string) ([]string, error)

type CreateVolume

type CreateVolume struct {
	Availabilityzone *string `awsName:"AvailabilityZone" awsType:"awsstr" templateName:"availabilityzone" required:""`
	Size             *int64  `awsName:"Size" awsType:"awsint64" templateName:"size" required:""`
	// contains filtered or unexported fields
}

func NewCreateVolume

func NewCreateVolume(sess *session.Session, l ...*logger.Logger) *CreateVolume

func (*CreateVolume) DryRun

func (cmd *CreateVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateVolume) ExtractResult

func (cmd *CreateVolume) ExtractResult(i interface{}) string

func (*CreateVolume) ParamsHelp

func (cmd *CreateVolume) ParamsHelp() string

func (*CreateVolume) Run

func (cmd *CreateVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateVolume) SetApi

func (cmd *CreateVolume) SetApi(api ec2iface.EC2API)

func (*CreateVolume) ValidateCommand

func (cmd *CreateVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateVolume) ValidateParams

func (cmd *CreateVolume) ValidateParams(params []string) ([]string, error)

type CreateVpc

type CreateVpc struct {
	CIDR *string `awsName:"CidrBlock" awsType:"awsstr" templateName:"cidr" required:""`
	Name *string `awsName:"Name" templateName:"name"`
	// contains filtered or unexported fields
}

func NewCreateVpc

func NewCreateVpc(sess *session.Session, l ...*logger.Logger) *CreateVpc

func (*CreateVpc) AfterRun

func (cmd *CreateVpc) AfterRun(ctx map[string]interface{}, output interface{}) error

func (*CreateVpc) DryRun

func (cmd *CreateVpc) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateVpc) ExtractResult

func (cmd *CreateVpc) ExtractResult(i interface{}) string

func (*CreateVpc) ParamsHelp

func (cmd *CreateVpc) ParamsHelp() string

func (*CreateVpc) Run

func (cmd *CreateVpc) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateVpc) SetApi

func (cmd *CreateVpc) SetApi(api ec2iface.EC2API)

func (*CreateVpc) ValidateCommand

func (cmd *CreateVpc) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateVpc) ValidateParams

func (cmd *CreateVpc) ValidateParams(params []string) ([]string, error)

func (*CreateVpc) Validate_CIDR

func (cmd *CreateVpc) Validate_CIDR() error

type CreateZone

type CreateZone struct {
	Callerreference *string `awsName:"CallerReference" awsType:"awsstr" templateName:"callerreference" required:""`
	Name            *string `awsName:"Name" awsType:"awsstr" templateName:"name" required:""`
	Delegationsetid *string `awsName:"DelegationSetId" awsType:"awsstr" templateName:"delegationsetid"`
	Comment         *string `awsName:"HostedZoneConfig.Comment" awsType:"awsstr" templateName:"comment"`
	Isprivate       *bool   `awsName:"HostedZoneConfig.PrivateZone" awsType:"awsbool" templateName:"isprivate"`
	Vpcid           *string `awsName:"VPC.VPCId" awsType:"awsstr" templateName:"vpcid"`
	Vpcregion       *string `awsName:"VPC.VPCRegion" awsType:"awsstr" templateName:"vpcregion"`
	// contains filtered or unexported fields
}

func NewCreateZone

func NewCreateZone(sess *session.Session, l ...*logger.Logger) *CreateZone

func (*CreateZone) DryRun

func (cmd *CreateZone) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateZone) ExtractResult

func (cmd *CreateZone) ExtractResult(i interface{}) string

func (*CreateZone) ParamsHelp

func (cmd *CreateZone) ParamsHelp() string

func (*CreateZone) Run

func (cmd *CreateZone) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*CreateZone) SetApi

func (cmd *CreateZone) SetApi(api route53iface.Route53API)

func (*CreateZone) ValidateCommand

func (cmd *CreateZone) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*CreateZone) ValidateParams

func (cmd *CreateZone) ValidateParams(params []string) ([]string, error)

type Definition

type Definition struct {
	Action, Entity, Api         string
	RequiredParams, ExtraParams []string
}

func AWSLookupDefinitions

func AWSLookupDefinitions(key string) (t Definition, ok bool)

type DeleteAccesskey

type DeleteAccesskey struct {
	Id   *string `awsName:"AccessKeyId" awsType:"awsstr" templateName:"id" required:""`
	User *string `awsName:"UserName" awsType:"awsstr" templateName:"user"`
	// contains filtered or unexported fields
}

func NewDeleteAccesskey

func NewDeleteAccesskey(sess *session.Session, l ...*logger.Logger) *DeleteAccesskey

func (*DeleteAccesskey) DryRun

func (cmd *DeleteAccesskey) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAccesskey) ParamsHelp

func (cmd *DeleteAccesskey) ParamsHelp() string

func (*DeleteAccesskey) Run

func (cmd *DeleteAccesskey) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAccesskey) SetApi

func (cmd *DeleteAccesskey) SetApi(api iamiface.IAMAPI)

func (*DeleteAccesskey) ValidateCommand

func (cmd *DeleteAccesskey) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteAccesskey) ValidateParams

func (cmd *DeleteAccesskey) ValidateParams(params []string) ([]string, error)

type DeleteAlarm

type DeleteAlarm struct {
	Name []*string `awsName:"AlarmNames" awsType:"awsstringslice" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteAlarm

func NewDeleteAlarm(sess *session.Session, l ...*logger.Logger) *DeleteAlarm

func (*DeleteAlarm) DryRun

func (cmd *DeleteAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAlarm) ParamsHelp

func (cmd *DeleteAlarm) ParamsHelp() string

func (*DeleteAlarm) Run

func (cmd *DeleteAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAlarm) SetApi

func (cmd *DeleteAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*DeleteAlarm) ValidateCommand

func (cmd *DeleteAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteAlarm) ValidateParams

func (cmd *DeleteAlarm) ValidateParams(params []string) ([]string, error)

type DeleteAppscalingpolicy

type DeleteAppscalingpolicy struct {
	Name             *string `awsName:"PolicyName" awsType:"awsstr" templateName:"name" required:""`
	Resource         *string `awsName:"ResourceId" awsType:"awsstr" templateName:"resource" required:""`
	Dimension        *string `awsName:"ScalableDimension" awsType:"awsstr" templateName:"dimension" required:""`
	ServiceNamespace *string `awsName:"ServiceNamespace" awsType:"awsstr" templateName:"service-namespace" required:""`
	// contains filtered or unexported fields
}

func NewDeleteAppscalingpolicy

func NewDeleteAppscalingpolicy(sess *session.Session, l ...*logger.Logger) *DeleteAppscalingpolicy

func (*DeleteAppscalingpolicy) DryRun

func (cmd *DeleteAppscalingpolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAppscalingpolicy) ParamsHelp

func (cmd *DeleteAppscalingpolicy) ParamsHelp() string

func (*DeleteAppscalingpolicy) Run

func (cmd *DeleteAppscalingpolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAppscalingpolicy) SetApi

func (*DeleteAppscalingpolicy) ValidateCommand

func (cmd *DeleteAppscalingpolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteAppscalingpolicy) ValidateParams

func (cmd *DeleteAppscalingpolicy) ValidateParams(params []string) ([]string, error)

type DeleteAppscalingtarget

type DeleteAppscalingtarget struct {
	Resource         *string `awsName:"ResourceId" awsType:"awsstr" templateName:"resource" required:""`
	Dimension        *string `awsName:"ScalableDimension" awsType:"awsstr" templateName:"dimension" required:""`
	ServiceNamespace *string `awsName:"ServiceNamespace" awsType:"awsstr" templateName:"service-namespace" required:""`
	// contains filtered or unexported fields
}

func NewDeleteAppscalingtarget

func NewDeleteAppscalingtarget(sess *session.Session, l ...*logger.Logger) *DeleteAppscalingtarget

func (*DeleteAppscalingtarget) DryRun

func (cmd *DeleteAppscalingtarget) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAppscalingtarget) ParamsHelp

func (cmd *DeleteAppscalingtarget) ParamsHelp() string

func (*DeleteAppscalingtarget) Run

func (cmd *DeleteAppscalingtarget) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteAppscalingtarget) SetApi

func (*DeleteAppscalingtarget) ValidateCommand

func (cmd *DeleteAppscalingtarget) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteAppscalingtarget) ValidateParams

func (cmd *DeleteAppscalingtarget) ValidateParams(params []string) ([]string, error)

type DeleteBucket

type DeleteBucket struct {
	Name *string `awsName:"Bucket" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteBucket

func NewDeleteBucket(sess *session.Session, l ...*logger.Logger) *DeleteBucket

func (*DeleteBucket) DryRun

func (cmd *DeleteBucket) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteBucket) ParamsHelp

func (cmd *DeleteBucket) ParamsHelp() string

func (*DeleteBucket) Run

func (cmd *DeleteBucket) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteBucket) SetApi

func (cmd *DeleteBucket) SetApi(api s3iface.S3API)

func (*DeleteBucket) ValidateCommand

func (cmd *DeleteBucket) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteBucket) ValidateParams

func (cmd *DeleteBucket) ValidateParams(params []string) ([]string, error)

type DeleteCertificate

type DeleteCertificate struct {
	Arn *string `awsName:"CertificateArn" awsType:"awsstr" templateName:"arn" required:""`
	// contains filtered or unexported fields
}

func NewDeleteCertificate

func NewDeleteCertificate(sess *session.Session, l ...*logger.Logger) *DeleteCertificate

func (*DeleteCertificate) DryRun

func (cmd *DeleteCertificate) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteCertificate) ParamsHelp

func (cmd *DeleteCertificate) ParamsHelp() string

func (*DeleteCertificate) Run

func (cmd *DeleteCertificate) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteCertificate) SetApi

func (cmd *DeleteCertificate) SetApi(api acmiface.ACMAPI)

func (*DeleteCertificate) ValidateCommand

func (cmd *DeleteCertificate) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteCertificate) ValidateParams

func (cmd *DeleteCertificate) ValidateParams(params []string) ([]string, error)

type DeleteContainercluster

type DeleteContainercluster struct {
	Id *string `awsName:"Cluster" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteContainercluster

func NewDeleteContainercluster(sess *session.Session, l ...*logger.Logger) *DeleteContainercluster

func (*DeleteContainercluster) DryRun

func (cmd *DeleteContainercluster) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteContainercluster) ParamsHelp

func (cmd *DeleteContainercluster) ParamsHelp() string

func (*DeleteContainercluster) Run

func (cmd *DeleteContainercluster) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteContainercluster) SetApi

func (cmd *DeleteContainercluster) SetApi(api ecsiface.ECSAPI)

func (*DeleteContainercluster) ValidateCommand

func (cmd *DeleteContainercluster) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteContainercluster) ValidateParams

func (cmd *DeleteContainercluster) ValidateParams(params []string) ([]string, error)

type DeleteContainertask

type DeleteContainertask struct {
	Name        *string `templateName:"name" required:""`
	AllVersions *bool   `templateName:"all-versions"`
	// contains filtered or unexported fields
}

func NewDeleteContainertask

func NewDeleteContainertask(sess *session.Session, l ...*logger.Logger) *DeleteContainertask

func (*DeleteContainertask) DryRun

func (cmd *DeleteContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteContainertask) ManualRun

func (cmd *DeleteContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteContainertask) ParamsHelp

func (cmd *DeleteContainertask) ParamsHelp() string

func (*DeleteContainertask) Run

func (cmd *DeleteContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteContainertask) SetApi

func (cmd *DeleteContainertask) SetApi(api ecsiface.ECSAPI)

func (*DeleteContainertask) ValidateCommand

func (cmd *DeleteContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteContainertask) ValidateParams

func (cmd *DeleteContainertask) ValidateParams(params []string) ([]string, error)

type DeleteDatabase

type DeleteDatabase struct {
	Id           *string `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"id" required:""`
	SkipSnapshot *bool   `awsName:"SkipFinalSnapshot" awsType:"awsbool" templateName:"skip-snapshot"`
	Snapshot     *string `awsName:"FinalDBSnapshotIdentifier" awsType:"awsstr" templateName:"snapshot"`
	// contains filtered or unexported fields
}

func NewDeleteDatabase

func NewDeleteDatabase(sess *session.Session, l ...*logger.Logger) *DeleteDatabase

func (*DeleteDatabase) DryRun

func (cmd *DeleteDatabase) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteDatabase) ParamsHelp

func (cmd *DeleteDatabase) ParamsHelp() string

func (*DeleteDatabase) Run

func (cmd *DeleteDatabase) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteDatabase) SetApi

func (cmd *DeleteDatabase) SetApi(api rdsiface.RDSAPI)

func (*DeleteDatabase) ValidateCommand

func (cmd *DeleteDatabase) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteDatabase) ValidateParams

func (cmd *DeleteDatabase) ValidateParams(params []string) ([]string, error)

type DeleteDbsubnetgroup

type DeleteDbsubnetgroup struct {
	Name *string `awsName:"DBSubnetGroupName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteDbsubnetgroup

func NewDeleteDbsubnetgroup(sess *session.Session, l ...*logger.Logger) *DeleteDbsubnetgroup

func (*DeleteDbsubnetgroup) DryRun

func (cmd *DeleteDbsubnetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteDbsubnetgroup) ParamsHelp

func (cmd *DeleteDbsubnetgroup) ParamsHelp() string

func (*DeleteDbsubnetgroup) Run

func (cmd *DeleteDbsubnetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteDbsubnetgroup) SetApi

func (cmd *DeleteDbsubnetgroup) SetApi(api rdsiface.RDSAPI)

func (*DeleteDbsubnetgroup) ValidateCommand

func (cmd *DeleteDbsubnetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteDbsubnetgroup) ValidateParams

func (cmd *DeleteDbsubnetgroup) ValidateParams(params []string) ([]string, error)

type DeleteDistribution

type DeleteDistribution struct {
	Id *string `awsName:"Id" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteDistribution

func NewDeleteDistribution(sess *session.Session, l ...*logger.Logger) *DeleteDistribution

func (*DeleteDistribution) DryRun

func (cmd *DeleteDistribution) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteDistribution) ManualRun

func (cmd *DeleteDistribution) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteDistribution) ParamsHelp

func (cmd *DeleteDistribution) ParamsHelp() string

func (*DeleteDistribution) Run

func (cmd *DeleteDistribution) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteDistribution) SetApi

func (*DeleteDistribution) ValidateCommand

func (cmd *DeleteDistribution) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteDistribution) ValidateParams

func (cmd *DeleteDistribution) ValidateParams(params []string) ([]string, error)

type DeleteElasticip

type DeleteElasticip struct {
	Id *string `awsName:"AllocationId" awsType:"awsstr" templateName:"id"`
	Ip *string `awsName:"PublicIp" awsType:"awsstr" templateName:"ip"`
	// contains filtered or unexported fields
}

func NewDeleteElasticip

func NewDeleteElasticip(sess *session.Session, l ...*logger.Logger) *DeleteElasticip

func (*DeleteElasticip) DryRun

func (cmd *DeleteElasticip) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteElasticip) ParamsHelp

func (cmd *DeleteElasticip) ParamsHelp() string

func (*DeleteElasticip) Run

func (cmd *DeleteElasticip) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteElasticip) SetApi

func (cmd *DeleteElasticip) SetApi(api ec2iface.EC2API)

func (*DeleteElasticip) ValidateCommand

func (cmd *DeleteElasticip) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteElasticip) ValidateParams

func (cmd *DeleteElasticip) ValidateParams(params []string) ([]string, error)

type DeleteFunction

type DeleteFunction struct {
	Id      *string `awsName:"FunctionName" awsType:"awsstr" templateName:"id" required:""`
	Version *string `awsName:"Qualifier" awsType:"awsstr" templateName:"version"`
	// contains filtered or unexported fields
}

func NewDeleteFunction

func NewDeleteFunction(sess *session.Session, l ...*logger.Logger) *DeleteFunction

func (*DeleteFunction) DryRun

func (cmd *DeleteFunction) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteFunction) ParamsHelp

func (cmd *DeleteFunction) ParamsHelp() string

func (*DeleteFunction) Run

func (cmd *DeleteFunction) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteFunction) SetApi

func (cmd *DeleteFunction) SetApi(api lambdaiface.LambdaAPI)

func (*DeleteFunction) ValidateCommand

func (cmd *DeleteFunction) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteFunction) ValidateParams

func (cmd *DeleteFunction) ValidateParams(params []string) ([]string, error)

type DeleteGroup

type DeleteGroup struct {
	Name *string `awsName:"GroupName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteGroup

func NewDeleteGroup(sess *session.Session, l ...*logger.Logger) *DeleteGroup

func (*DeleteGroup) DryRun

func (cmd *DeleteGroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteGroup) ParamsHelp

func (cmd *DeleteGroup) ParamsHelp() string

func (*DeleteGroup) Run

func (cmd *DeleteGroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteGroup) SetApi

func (cmd *DeleteGroup) SetApi(api iamiface.IAMAPI)

func (*DeleteGroup) ValidateCommand

func (cmd *DeleteGroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteGroup) ValidateParams

func (cmd *DeleteGroup) ValidateParams(params []string) ([]string, error)

type DeleteImage

type DeleteImage struct {
	Id              *string `templateName:"id" required:""`
	DeleteSnapshots *bool   `templateName:"delete-snapshots"`
	// contains filtered or unexported fields
}

func NewDeleteImage

func NewDeleteImage(sess *session.Session, l ...*logger.Logger) *DeleteImage

func (*DeleteImage) DryRun

func (cmd *DeleteImage) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteImage) ManualRun

func (cmd *DeleteImage) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteImage) ParamsHelp

func (cmd *DeleteImage) ParamsHelp() string

func (*DeleteImage) Run

func (cmd *DeleteImage) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteImage) SetApi

func (cmd *DeleteImage) SetApi(api ec2iface.EC2API)

func (*DeleteImage) ValidateCommand

func (cmd *DeleteImage) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteImage) ValidateParams

func (cmd *DeleteImage) ValidateParams(params []string) ([]string, error)

type DeleteInstance

type DeleteInstance struct {
	IDs []*string `awsName:"InstanceIds" awsType:"awsstringslice" templateName:"ids"`
	// contains filtered or unexported fields
}

func NewDeleteInstance

func NewDeleteInstance(sess *session.Session, l ...*logger.Logger) *DeleteInstance

func (*DeleteInstance) ConvertParams

func (cmd *DeleteInstance) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]interface{}, error))

func (*DeleteInstance) DryRun

func (cmd *DeleteInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteInstance) ParamsHelp

func (cmd *DeleteInstance) ParamsHelp() string

func (*DeleteInstance) Run

func (cmd *DeleteInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteInstance) SetApi

func (cmd *DeleteInstance) SetApi(api ec2iface.EC2API)

func (*DeleteInstance) ValidateCommand

func (cmd *DeleteInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteInstance) ValidateParams

func (cmd *DeleteInstance) ValidateParams(params []string) ([]string, error)

type DeleteInstanceprofile

type DeleteInstanceprofile struct {
	Name *string `awsName:"InstanceProfileName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteInstanceprofile

func NewDeleteInstanceprofile(sess *session.Session, l ...*logger.Logger) *DeleteInstanceprofile

func (*DeleteInstanceprofile) DryRun

func (cmd *DeleteInstanceprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteInstanceprofile) ParamsHelp

func (cmd *DeleteInstanceprofile) ParamsHelp() string

func (*DeleteInstanceprofile) Run

func (cmd *DeleteInstanceprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteInstanceprofile) SetApi

func (cmd *DeleteInstanceprofile) SetApi(api iamiface.IAMAPI)

func (*DeleteInstanceprofile) ValidateCommand

func (cmd *DeleteInstanceprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteInstanceprofile) ValidateParams

func (cmd *DeleteInstanceprofile) ValidateParams(params []string) ([]string, error)

type DeleteInternetgateway

type DeleteInternetgateway struct {
	Id *string `awsName:"InternetGatewayId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteInternetgateway

func NewDeleteInternetgateway(sess *session.Session, l ...*logger.Logger) *DeleteInternetgateway

func (*DeleteInternetgateway) DryRun

func (cmd *DeleteInternetgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteInternetgateway) ParamsHelp

func (cmd *DeleteInternetgateway) ParamsHelp() string

func (*DeleteInternetgateway) Run

func (cmd *DeleteInternetgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteInternetgateway) SetApi

func (cmd *DeleteInternetgateway) SetApi(api ec2iface.EC2API)

func (*DeleteInternetgateway) ValidateCommand

func (cmd *DeleteInternetgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteInternetgateway) ValidateParams

func (cmd *DeleteInternetgateway) ValidateParams(params []string) ([]string, error)

type DeleteKeypair

type DeleteKeypair struct {
	Name *string `awsName:"KeyName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteKeypair

func NewDeleteKeypair(sess *session.Session, l ...*logger.Logger) *DeleteKeypair

func (*DeleteKeypair) DryRun

func (cmd *DeleteKeypair) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteKeypair) ParamsHelp

func (cmd *DeleteKeypair) ParamsHelp() string

func (*DeleteKeypair) Run

func (cmd *DeleteKeypair) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteKeypair) SetApi

func (cmd *DeleteKeypair) SetApi(api ec2iface.EC2API)

func (*DeleteKeypair) ValidateCommand

func (cmd *DeleteKeypair) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteKeypair) ValidateParams

func (cmd *DeleteKeypair) ValidateParams(params []string) ([]string, error)

type DeleteLaunchconfiguration

type DeleteLaunchconfiguration struct {
	Name *string `awsName:"LaunchConfigurationName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteLaunchconfiguration

func NewDeleteLaunchconfiguration(sess *session.Session, l ...*logger.Logger) *DeleteLaunchconfiguration

func (*DeleteLaunchconfiguration) DryRun

func (cmd *DeleteLaunchconfiguration) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteLaunchconfiguration) ParamsHelp

func (cmd *DeleteLaunchconfiguration) ParamsHelp() string

func (*DeleteLaunchconfiguration) Run

func (cmd *DeleteLaunchconfiguration) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteLaunchconfiguration) SetApi

func (*DeleteLaunchconfiguration) ValidateCommand

func (cmd *DeleteLaunchconfiguration) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteLaunchconfiguration) ValidateParams

func (cmd *DeleteLaunchconfiguration) ValidateParams(params []string) ([]string, error)

type DeleteListener

type DeleteListener struct {
	Id *string `awsName:"ListenerArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteListener

func NewDeleteListener(sess *session.Session, l ...*logger.Logger) *DeleteListener

func (*DeleteListener) DryRun

func (cmd *DeleteListener) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteListener) ParamsHelp

func (cmd *DeleteListener) ParamsHelp() string

func (*DeleteListener) Run

func (cmd *DeleteListener) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteListener) SetApi

func (cmd *DeleteListener) SetApi(api elbv2iface.ELBV2API)

func (*DeleteListener) ValidateCommand

func (cmd *DeleteListener) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteListener) ValidateParams

func (cmd *DeleteListener) ValidateParams(params []string) ([]string, error)

type DeleteLoadbalancer

type DeleteLoadbalancer struct {
	Id *string `awsName:"LoadBalancerArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteLoadbalancer

func NewDeleteLoadbalancer(sess *session.Session, l ...*logger.Logger) *DeleteLoadbalancer

func (*DeleteLoadbalancer) DryRun

func (cmd *DeleteLoadbalancer) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteLoadbalancer) ParamsHelp

func (cmd *DeleteLoadbalancer) ParamsHelp() string

func (*DeleteLoadbalancer) Run

func (cmd *DeleteLoadbalancer) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteLoadbalancer) SetApi

func (cmd *DeleteLoadbalancer) SetApi(api elbv2iface.ELBV2API)

func (*DeleteLoadbalancer) ValidateCommand

func (cmd *DeleteLoadbalancer) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteLoadbalancer) ValidateParams

func (cmd *DeleteLoadbalancer) ValidateParams(params []string) ([]string, error)

type DeleteLoginprofile

type DeleteLoginprofile struct {
	Username *string `awsName:"UserName" awsType:"awsstr" templateName:"username" required:""`
	// contains filtered or unexported fields
}

func NewDeleteLoginprofile

func NewDeleteLoginprofile(sess *session.Session, l ...*logger.Logger) *DeleteLoginprofile

func (*DeleteLoginprofile) DryRun

func (cmd *DeleteLoginprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteLoginprofile) ParamsHelp

func (cmd *DeleteLoginprofile) ParamsHelp() string

func (*DeleteLoginprofile) Run

func (cmd *DeleteLoginprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteLoginprofile) SetApi

func (cmd *DeleteLoginprofile) SetApi(api iamiface.IAMAPI)

func (*DeleteLoginprofile) ValidateCommand

func (cmd *DeleteLoginprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteLoginprofile) ValidateParams

func (cmd *DeleteLoginprofile) ValidateParams(params []string) ([]string, error)

type DeleteMfadevice

type DeleteMfadevice struct {
	Id *string `awsName:"SerialNumber" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteMfadevice

func NewDeleteMfadevice(sess *session.Session, l ...*logger.Logger) *DeleteMfadevice

func (*DeleteMfadevice) DryRun

func (cmd *DeleteMfadevice) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteMfadevice) ParamsHelp

func (cmd *DeleteMfadevice) ParamsHelp() string

func (*DeleteMfadevice) Run

func (cmd *DeleteMfadevice) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteMfadevice) SetApi

func (cmd *DeleteMfadevice) SetApi(api iamiface.IAMAPI)

func (*DeleteMfadevice) ValidateCommand

func (cmd *DeleteMfadevice) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteMfadevice) ValidateParams

func (cmd *DeleteMfadevice) ValidateParams(params []string) ([]string, error)

type DeleteNatgateway

type DeleteNatgateway struct {
	Id *string `awsName:"NatGatewayId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteNatgateway

func NewDeleteNatgateway(sess *session.Session, l ...*logger.Logger) *DeleteNatgateway

func (*DeleteNatgateway) DryRun

func (cmd *DeleteNatgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteNatgateway) ParamsHelp

func (cmd *DeleteNatgateway) ParamsHelp() string

func (*DeleteNatgateway) Run

func (cmd *DeleteNatgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteNatgateway) SetApi

func (cmd *DeleteNatgateway) SetApi(api ec2iface.EC2API)

func (*DeleteNatgateway) ValidateCommand

func (cmd *DeleteNatgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteNatgateway) ValidateParams

func (cmd *DeleteNatgateway) ValidateParams(params []string) ([]string, error)

type DeleteNetworkinterface

type DeleteNetworkinterface struct {
	Id *string `awsName:"NetworkInterfaceId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteNetworkinterface

func NewDeleteNetworkinterface(sess *session.Session, l ...*logger.Logger) *DeleteNetworkinterface

func (*DeleteNetworkinterface) DryRun

func (cmd *DeleteNetworkinterface) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteNetworkinterface) ParamsHelp

func (cmd *DeleteNetworkinterface) ParamsHelp() string

func (*DeleteNetworkinterface) Run

func (cmd *DeleteNetworkinterface) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteNetworkinterface) SetApi

func (cmd *DeleteNetworkinterface) SetApi(api ec2iface.EC2API)

func (*DeleteNetworkinterface) ValidateCommand

func (cmd *DeleteNetworkinterface) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteNetworkinterface) ValidateParams

func (cmd *DeleteNetworkinterface) ValidateParams(params []string) ([]string, error)

type DeletePolicy

type DeletePolicy struct {
	Arn         *string `awsName:"PolicyArn" awsType:"awsstr" templateName:"arn" required:""`
	AllVersions *bool   `templateName:"all-versions"`
	// contains filtered or unexported fields
}

func NewDeletePolicy

func NewDeletePolicy(sess *session.Session, l ...*logger.Logger) *DeletePolicy

func (*DeletePolicy) BeforeRun

func (cmd *DeletePolicy) BeforeRun(ctx map[string]interface{}) error

func (*DeletePolicy) DryRun

func (cmd *DeletePolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeletePolicy) ParamsHelp

func (cmd *DeletePolicy) ParamsHelp() string

func (*DeletePolicy) Run

func (cmd *DeletePolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeletePolicy) SetApi

func (cmd *DeletePolicy) SetApi(api iamiface.IAMAPI)

func (*DeletePolicy) ValidateCommand

func (cmd *DeletePolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeletePolicy) ValidateParams

func (cmd *DeletePolicy) ValidateParams(params []string) ([]string, error)

type DeleteQueue

type DeleteQueue struct {
	Url *string `awsName:"QueueUrl" awsType:"awsstr" templateName:"url" required:""`
	// contains filtered or unexported fields
}

func NewDeleteQueue

func NewDeleteQueue(sess *session.Session, l ...*logger.Logger) *DeleteQueue

func (*DeleteQueue) DryRun

func (cmd *DeleteQueue) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteQueue) ParamsHelp

func (cmd *DeleteQueue) ParamsHelp() string

func (*DeleteQueue) Run

func (cmd *DeleteQueue) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteQueue) SetApi

func (cmd *DeleteQueue) SetApi(api sqsiface.SQSAPI)

func (*DeleteQueue) ValidateCommand

func (cmd *DeleteQueue) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteQueue) ValidateParams

func (cmd *DeleteQueue) ValidateParams(params []string) ([]string, error)

type DeleteRecord

type DeleteRecord struct {
	Zone  *string `templateName:"zone" required:""`
	Name  *string `templateName:"name" required:""`
	Type  *string `templateName:"type" required:""`
	Value *string `templateName:"value" required:""`
	Ttl   *int64  `templateName:"ttl" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRecord

func NewDeleteRecord(sess *session.Session, l ...*logger.Logger) *DeleteRecord

func (*DeleteRecord) DryRun

func (cmd *DeleteRecord) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRecord) ExtractResult

func (cmd *DeleteRecord) ExtractResult(i interface{}) string

func (*DeleteRecord) ManualRun

func (cmd *DeleteRecord) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteRecord) ParamsHelp

func (cmd *DeleteRecord) ParamsHelp() string

func (*DeleteRecord) Run

func (cmd *DeleteRecord) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRecord) SetApi

func (cmd *DeleteRecord) SetApi(api route53iface.Route53API)

func (*DeleteRecord) ValidateCommand

func (cmd *DeleteRecord) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRecord) ValidateParams

func (cmd *DeleteRecord) ValidateParams(params []string) ([]string, error)

type DeleteRepository

type DeleteRepository struct {
	Name    *string `awsName:"RepositoryName" awsType:"awsstr" templateName:"name" required:""`
	Force   *bool   `awsName:"Force" awsType:"awsbool" templateName:"force"`
	Account *string `awsName:"RegistryId" awsType:"awsstr" templateName:"account"`
	// contains filtered or unexported fields
}

func NewDeleteRepository

func NewDeleteRepository(sess *session.Session, l ...*logger.Logger) *DeleteRepository

func (*DeleteRepository) DryRun

func (cmd *DeleteRepository) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRepository) ParamsHelp

func (cmd *DeleteRepository) ParamsHelp() string

func (*DeleteRepository) Run

func (cmd *DeleteRepository) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRepository) SetApi

func (cmd *DeleteRepository) SetApi(api ecriface.ECRAPI)

func (*DeleteRepository) ValidateCommand

func (cmd *DeleteRepository) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRepository) ValidateParams

func (cmd *DeleteRepository) ValidateParams(params []string) ([]string, error)

type DeleteRole

type DeleteRole struct {
	Name *string `awsName:"RoleName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRole

func NewDeleteRole(sess *session.Session, l ...*logger.Logger) *DeleteRole

func (*DeleteRole) DryRun

func (cmd *DeleteRole) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRole) ManualRun

func (cmd *DeleteRole) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteRole) ParamsHelp

func (cmd *DeleteRole) ParamsHelp() string

func (*DeleteRole) Run

func (cmd *DeleteRole) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRole) SetApi

func (cmd *DeleteRole) SetApi(api iamiface.IAMAPI)

func (*DeleteRole) ValidateCommand

func (cmd *DeleteRole) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRole) ValidateParams

func (cmd *DeleteRole) ValidateParams(params []string) ([]string, error)

type DeleteRoute

type DeleteRoute struct {
	Table *string `awsName:"RouteTableId" awsType:"awsstr" templateName:"table" required:""`
	CIDR  *string `awsName:"DestinationCidrBlock" awsType:"awsstr" templateName:"cidr" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRoute

func NewDeleteRoute(sess *session.Session, l ...*logger.Logger) *DeleteRoute

func (*DeleteRoute) DryRun

func (cmd *DeleteRoute) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoute) ParamsHelp

func (cmd *DeleteRoute) ParamsHelp() string

func (*DeleteRoute) Run

func (cmd *DeleteRoute) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoute) SetApi

func (cmd *DeleteRoute) SetApi(api ec2iface.EC2API)

func (*DeleteRoute) ValidateCommand

func (cmd *DeleteRoute) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRoute) ValidateParams

func (cmd *DeleteRoute) ValidateParams(params []string) ([]string, error)

func (*DeleteRoute) Validate_CIDR

func (cmd *DeleteRoute) Validate_CIDR() error

type DeleteRoutetable

type DeleteRoutetable struct {
	Id *string `awsName:"RouteTableId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRoutetable

func NewDeleteRoutetable(sess *session.Session, l ...*logger.Logger) *DeleteRoutetable

func (*DeleteRoutetable) DryRun

func (cmd *DeleteRoutetable) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoutetable) ParamsHelp

func (cmd *DeleteRoutetable) ParamsHelp() string

func (*DeleteRoutetable) Run

func (cmd *DeleteRoutetable) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoutetable) SetApi

func (cmd *DeleteRoutetable) SetApi(api ec2iface.EC2API)

func (*DeleteRoutetable) ValidateCommand

func (cmd *DeleteRoutetable) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRoutetable) ValidateParams

func (cmd *DeleteRoutetable) ValidateParams(params []string) ([]string, error)

type DeleteS3object

type DeleteS3object struct {
	Bucket *string `awsName:"Bucket" awsType:"awsstr" templateName:"bucket" required:""`
	Name   *string `awsName:"Key" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteS3object

func NewDeleteS3object(sess *session.Session, l ...*logger.Logger) *DeleteS3object

func (*DeleteS3object) DryRun

func (cmd *DeleteS3object) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteS3object) ParamsHelp

func (cmd *DeleteS3object) ParamsHelp() string

func (*DeleteS3object) Run

func (cmd *DeleteS3object) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteS3object) SetApi

func (cmd *DeleteS3object) SetApi(api s3iface.S3API)

func (*DeleteS3object) ValidateCommand

func (cmd *DeleteS3object) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteS3object) ValidateParams

func (cmd *DeleteS3object) ValidateParams(params []string) ([]string, error)

type DeleteScalinggroup

type DeleteScalinggroup struct {
	Name  *string `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name" required:""`
	Force *bool   `awsName:"ForceDelete" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDeleteScalinggroup

func NewDeleteScalinggroup(sess *session.Session, l ...*logger.Logger) *DeleteScalinggroup

func (*DeleteScalinggroup) DryRun

func (cmd *DeleteScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalinggroup) ParamsHelp

func (cmd *DeleteScalinggroup) ParamsHelp() string

func (*DeleteScalinggroup) Run

func (cmd *DeleteScalinggroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalinggroup) SetApi

func (*DeleteScalinggroup) ValidateCommand

func (cmd *DeleteScalinggroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteScalinggroup) ValidateParams

func (cmd *DeleteScalinggroup) ValidateParams(params []string) ([]string, error)

type DeleteScalingpolicy

type DeleteScalingpolicy struct {
	Id *string `awsName:"PolicyName" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteScalingpolicy

func NewDeleteScalingpolicy(sess *session.Session, l ...*logger.Logger) *DeleteScalingpolicy

func (*DeleteScalingpolicy) DryRun

func (cmd *DeleteScalingpolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalingpolicy) ParamsHelp

func (cmd *DeleteScalingpolicy) ParamsHelp() string

func (*DeleteScalingpolicy) Run

func (cmd *DeleteScalingpolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalingpolicy) SetApi

func (*DeleteScalingpolicy) ValidateCommand

func (cmd *DeleteScalingpolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteScalingpolicy) ValidateParams

func (cmd *DeleteScalingpolicy) ValidateParams(params []string) ([]string, error)

type DeleteSecuritygroup

type DeleteSecuritygroup struct {
	Id *string `awsName:"GroupId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSecuritygroup

func NewDeleteSecuritygroup(sess *session.Session, l ...*logger.Logger) *DeleteSecuritygroup

func (*DeleteSecuritygroup) DryRun

func (cmd *DeleteSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSecuritygroup) ParamsHelp

func (cmd *DeleteSecuritygroup) ParamsHelp() string

func (*DeleteSecuritygroup) Run

func (cmd *DeleteSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSecuritygroup) SetApi

func (cmd *DeleteSecuritygroup) SetApi(api ec2iface.EC2API)

func (*DeleteSecuritygroup) ValidateCommand

func (cmd *DeleteSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSecuritygroup) ValidateParams

func (cmd *DeleteSecuritygroup) ValidateParams(params []string) ([]string, error)

type DeleteSnapshot

type DeleteSnapshot struct {
	Id *string `awsName:"SnapshotId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSnapshot

func NewDeleteSnapshot(sess *session.Session, l ...*logger.Logger) *DeleteSnapshot

func (*DeleteSnapshot) DryRun

func (cmd *DeleteSnapshot) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSnapshot) ParamsHelp

func (cmd *DeleteSnapshot) ParamsHelp() string

func (*DeleteSnapshot) Run

func (cmd *DeleteSnapshot) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSnapshot) SetApi

func (cmd *DeleteSnapshot) SetApi(api ec2iface.EC2API)

func (*DeleteSnapshot) ValidateCommand

func (cmd *DeleteSnapshot) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSnapshot) ValidateParams

func (cmd *DeleteSnapshot) ValidateParams(params []string) ([]string, error)

type DeleteStack

type DeleteStack struct {
	Name            *string   `awsName:"StackName" awsType:"awsstr" templateName:"name" required:""`
	RetainResources []*string `awsName:"RetainResources" awsType:"awsstringslice" templateName:"retain-resources"`
	// contains filtered or unexported fields
}

func NewDeleteStack

func NewDeleteStack(sess *session.Session, l ...*logger.Logger) *DeleteStack

func (*DeleteStack) DryRun

func (cmd *DeleteStack) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteStack) ParamsHelp

func (cmd *DeleteStack) ParamsHelp() string

func (*DeleteStack) Run

func (cmd *DeleteStack) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteStack) SetApi

func (*DeleteStack) ValidateCommand

func (cmd *DeleteStack) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteStack) ValidateParams

func (cmd *DeleteStack) ValidateParams(params []string) ([]string, error)

type DeleteSubnet

type DeleteSubnet struct {
	Id *string `awsName:"SubnetId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSubnet

func NewDeleteSubnet(sess *session.Session, l ...*logger.Logger) *DeleteSubnet

func (*DeleteSubnet) DryRun

func (cmd *DeleteSubnet) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubnet) ParamsHelp

func (cmd *DeleteSubnet) ParamsHelp() string

func (*DeleteSubnet) Run

func (cmd *DeleteSubnet) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubnet) SetApi

func (cmd *DeleteSubnet) SetApi(api ec2iface.EC2API)

func (*DeleteSubnet) ValidateCommand

func (cmd *DeleteSubnet) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSubnet) ValidateParams

func (cmd *DeleteSubnet) ValidateParams(params []string) ([]string, error)

type DeleteSubscription

type DeleteSubscription struct {
	Id *string `awsName:"SubscriptionArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSubscription

func NewDeleteSubscription(sess *session.Session, l ...*logger.Logger) *DeleteSubscription

func (*DeleteSubscription) DryRun

func (cmd *DeleteSubscription) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubscription) ParamsHelp

func (cmd *DeleteSubscription) ParamsHelp() string

func (*DeleteSubscription) Run

func (cmd *DeleteSubscription) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubscription) SetApi

func (cmd *DeleteSubscription) SetApi(api snsiface.SNSAPI)

func (*DeleteSubscription) ValidateCommand

func (cmd *DeleteSubscription) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSubscription) ValidateParams

func (cmd *DeleteSubscription) ValidateParams(params []string) ([]string, error)

type DeleteTag

type DeleteTag struct {
	Resource *string `awsName:"Resources" awsType:"awsstringslice" templateName:"resource" required:""`
	Key      *string `templateName:"key" required:""`
	Value    *string `templateName:"value"`
	// contains filtered or unexported fields
}

func NewDeleteTag

func NewDeleteTag(sess *session.Session, l ...*logger.Logger) *DeleteTag

func (*DeleteTag) DryRun

func (cmd *DeleteTag) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTag) ManualRun

func (cmd *DeleteTag) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteTag) ParamsHelp

func (cmd *DeleteTag) ParamsHelp() string

func (*DeleteTag) Run

func (cmd *DeleteTag) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTag) SetApi

func (cmd *DeleteTag) SetApi(api ec2iface.EC2API)

func (*DeleteTag) ValidateCommand

func (cmd *DeleteTag) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteTag) ValidateParams

func (cmd *DeleteTag) ValidateParams(params []string) ([]string, error)

type DeleteTargetgroup

type DeleteTargetgroup struct {
	Id *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteTargetgroup

func NewDeleteTargetgroup(sess *session.Session, l ...*logger.Logger) *DeleteTargetgroup

func (*DeleteTargetgroup) DryRun

func (cmd *DeleteTargetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTargetgroup) ParamsHelp

func (cmd *DeleteTargetgroup) ParamsHelp() string

func (*DeleteTargetgroup) Run

func (cmd *DeleteTargetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTargetgroup) SetApi

func (cmd *DeleteTargetgroup) SetApi(api elbv2iface.ELBV2API)

func (*DeleteTargetgroup) ValidateCommand

func (cmd *DeleteTargetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteTargetgroup) ValidateParams

func (cmd *DeleteTargetgroup) ValidateParams(params []string) ([]string, error)

type DeleteTopic

type DeleteTopic struct {
	Id *string `awsName:"TopicArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteTopic

func NewDeleteTopic(sess *session.Session, l ...*logger.Logger) *DeleteTopic

func (*DeleteTopic) DryRun

func (cmd *DeleteTopic) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTopic) ParamsHelp

func (cmd *DeleteTopic) ParamsHelp() string

func (*DeleteTopic) Run

func (cmd *DeleteTopic) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTopic) SetApi

func (cmd *DeleteTopic) SetApi(api snsiface.SNSAPI)

func (*DeleteTopic) ValidateCommand

func (cmd *DeleteTopic) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteTopic) ValidateParams

func (cmd *DeleteTopic) ValidateParams(params []string) ([]string, error)

type DeleteUser

type DeleteUser struct {
	Name *string `awsName:"UserName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteUser

func NewDeleteUser(sess *session.Session, l ...*logger.Logger) *DeleteUser

func (*DeleteUser) DryRun

func (cmd *DeleteUser) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteUser) ParamsHelp

func (cmd *DeleteUser) ParamsHelp() string

func (*DeleteUser) Run

func (cmd *DeleteUser) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteUser) SetApi

func (cmd *DeleteUser) SetApi(api iamiface.IAMAPI)

func (*DeleteUser) ValidateCommand

func (cmd *DeleteUser) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteUser) ValidateParams

func (cmd *DeleteUser) ValidateParams(params []string) ([]string, error)

type DeleteVolume

type DeleteVolume struct {
	Id *string `awsName:"VolumeId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteVolume

func NewDeleteVolume(sess *session.Session, l ...*logger.Logger) *DeleteVolume

func (*DeleteVolume) DryRun

func (cmd *DeleteVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVolume) ParamsHelp

func (cmd *DeleteVolume) ParamsHelp() string

func (*DeleteVolume) Run

func (cmd *DeleteVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVolume) SetApi

func (cmd *DeleteVolume) SetApi(api ec2iface.EC2API)

func (*DeleteVolume) ValidateCommand

func (cmd *DeleteVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteVolume) ValidateParams

func (cmd *DeleteVolume) ValidateParams(params []string) ([]string, error)

type DeleteVpc

type DeleteVpc struct {
	Id *string `awsName:"VpcId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteVpc

func NewDeleteVpc(sess *session.Session, l ...*logger.Logger) *DeleteVpc

func (*DeleteVpc) DryRun

func (cmd *DeleteVpc) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVpc) ParamsHelp

func (cmd *DeleteVpc) ParamsHelp() string

func (*DeleteVpc) Run

func (cmd *DeleteVpc) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVpc) SetApi

func (cmd *DeleteVpc) SetApi(api ec2iface.EC2API)

func (*DeleteVpc) ValidateCommand

func (cmd *DeleteVpc) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteVpc) ValidateParams

func (cmd *DeleteVpc) ValidateParams(params []string) ([]string, error)

type DeleteZone

type DeleteZone struct {
	Id *string `awsName:"Id" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteZone

func NewDeleteZone(sess *session.Session, l ...*logger.Logger) *DeleteZone

func (*DeleteZone) DryRun

func (cmd *DeleteZone) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteZone) ParamsHelp

func (cmd *DeleteZone) ParamsHelp() string

func (*DeleteZone) Run

func (cmd *DeleteZone) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteZone) SetApi

func (cmd *DeleteZone) SetApi(api route53iface.Route53API)

func (*DeleteZone) ValidateCommand

func (cmd *DeleteZone) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteZone) ValidateParams

func (cmd *DeleteZone) ValidateParams(params []string) ([]string, error)

type DetachAlarm

type DetachAlarm struct {
	Name      *string `templateName:"name" required:""`
	ActionArn *string `templateName:"action-arn" required:""`
	// contains filtered or unexported fields
}

func NewDetachAlarm

func NewDetachAlarm(sess *session.Session, l ...*logger.Logger) *DetachAlarm

func (*DetachAlarm) DryRun

func (cmd *DetachAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachAlarm) ManualRun

func (cmd *DetachAlarm) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachAlarm) ParamsHelp

func (cmd *DetachAlarm) ParamsHelp() string

func (*DetachAlarm) Run

func (cmd *DetachAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachAlarm) SetApi

func (cmd *DetachAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*DetachAlarm) ValidateCommand

func (cmd *DetachAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachAlarm) ValidateParams

func (cmd *DetachAlarm) ValidateParams(params []string) ([]string, error)

type DetachContainertask

type DetachContainertask struct {
	Name          *string `templateName:"name" required:""`
	ContainerName *string `templateName:"container-name" required:""`
	// contains filtered or unexported fields
}

func NewDetachContainertask

func NewDetachContainertask(sess *session.Session, l ...*logger.Logger) *DetachContainertask

func (*DetachContainertask) DryRun

func (cmd *DetachContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachContainertask) ManualRun

func (cmd *DetachContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachContainertask) ParamsHelp

func (cmd *DetachContainertask) ParamsHelp() string

func (*DetachContainertask) Run

func (cmd *DetachContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachContainertask) SetApi

func (cmd *DetachContainertask) SetApi(api ecsiface.ECSAPI)

func (*DetachContainertask) ValidateCommand

func (cmd *DetachContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachContainertask) ValidateParams

func (cmd *DetachContainertask) ValidateParams(params []string) ([]string, error)

type DetachElasticip

type DetachElasticip struct {
	Association *string `awsName:"AssociationId" awsType:"awsstr" templateName:"association" required:""`
	// contains filtered or unexported fields
}

func NewDetachElasticip

func NewDetachElasticip(sess *session.Session, l ...*logger.Logger) *DetachElasticip

func (*DetachElasticip) DryRun

func (cmd *DetachElasticip) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachElasticip) ParamsHelp

func (cmd *DetachElasticip) ParamsHelp() string

func (*DetachElasticip) Run

func (cmd *DetachElasticip) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachElasticip) SetApi

func (cmd *DetachElasticip) SetApi(api ec2iface.EC2API)

func (*DetachElasticip) ValidateCommand

func (cmd *DetachElasticip) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachElasticip) ValidateParams

func (cmd *DetachElasticip) ValidateParams(params []string) ([]string, error)

type DetachInstance

type DetachInstance struct {
	Targetgroup *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"targetgroup" required:""`
	Id          *string `awsName:"Targets[0]Id" awsType:"awsslicestruct" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDetachInstance

func NewDetachInstance(sess *session.Session, l ...*logger.Logger) *DetachInstance

func (*DetachInstance) DryRun

func (cmd *DetachInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstance) ParamsHelp

func (cmd *DetachInstance) ParamsHelp() string

func (*DetachInstance) Run

func (cmd *DetachInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstance) SetApi

func (cmd *DetachInstance) SetApi(api elbv2iface.ELBV2API)

func (*DetachInstance) ValidateCommand

func (cmd *DetachInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachInstance) ValidateParams

func (cmd *DetachInstance) ValidateParams(params []string) ([]string, error)

type DetachInstanceprofile

type DetachInstanceprofile struct {
	Instance *string `templateName:"instance" required:""`
	Name     *string `templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDetachInstanceprofile

func NewDetachInstanceprofile(sess *session.Session, l ...*logger.Logger) *DetachInstanceprofile

func (*DetachInstanceprofile) DryRun

func (cmd *DetachInstanceprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstanceprofile) ExtractResult

func (cmd *DetachInstanceprofile) ExtractResult(i interface{}) string

func (*DetachInstanceprofile) ManualRun

func (cmd *DetachInstanceprofile) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachInstanceprofile) ParamsHelp

func (cmd *DetachInstanceprofile) ParamsHelp() string

func (*DetachInstanceprofile) Run

func (cmd *DetachInstanceprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstanceprofile) SetApi

func (cmd *DetachInstanceprofile) SetApi(api ec2iface.EC2API)

func (*DetachInstanceprofile) ValidateCommand

func (cmd *DetachInstanceprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachInstanceprofile) ValidateParams

func (cmd *DetachInstanceprofile) ValidateParams(params []string) ([]string, error)

type DetachInternetgateway

type DetachInternetgateway struct {
	Id  *string `awsName:"InternetGatewayId" awsType:"awsstr" templateName:"id" required:""`
	Vpc *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc" required:""`
	// contains filtered or unexported fields
}

func NewDetachInternetgateway

func NewDetachInternetgateway(sess *session.Session, l ...*logger.Logger) *DetachInternetgateway

func (*DetachInternetgateway) DryRun

func (cmd *DetachInternetgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInternetgateway) ParamsHelp

func (cmd *DetachInternetgateway) ParamsHelp() string

func (*DetachInternetgateway) Run

func (cmd *DetachInternetgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInternetgateway) SetApi

func (cmd *DetachInternetgateway) SetApi(api ec2iface.EC2API)

func (*DetachInternetgateway) ValidateCommand

func (cmd *DetachInternetgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachInternetgateway) ValidateParams

func (cmd *DetachInternetgateway) ValidateParams(params []string) ([]string, error)

type DetachMfadevice

type DetachMfadevice struct {
	Id   *string `awsName:"SerialNumber" awsType:"awsstr" templateName:"id" required:""`
	User *string `awsName:"UserName" awsType:"awsstr" templateName:"user" required:""`
	// contains filtered or unexported fields
}

func NewDetachMfadevice

func NewDetachMfadevice(sess *session.Session, l ...*logger.Logger) *DetachMfadevice

func (*DetachMfadevice) DryRun

func (cmd *DetachMfadevice) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachMfadevice) ParamsHelp

func (cmd *DetachMfadevice) ParamsHelp() string

func (*DetachMfadevice) Run

func (cmd *DetachMfadevice) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachMfadevice) SetApi

func (cmd *DetachMfadevice) SetApi(api iamiface.IAMAPI)

func (*DetachMfadevice) ValidateCommand

func (cmd *DetachMfadevice) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachMfadevice) ValidateParams

func (cmd *DetachMfadevice) ValidateParams(params []string) ([]string, error)

type DetachNetworkinterface

type DetachNetworkinterface struct {
	Attachment *string `awsName:"AttachmentId" awsType:"awsstr" templateName:"attachment"`
	Instance   *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance"`
	Id         *string `awsName:"NetworkInterfaceId" awsType:"awsstr" templateName:"id"`
	Force      *bool   `awsName:"Force" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDetachNetworkinterface

func NewDetachNetworkinterface(sess *session.Session, l ...*logger.Logger) *DetachNetworkinterface

func (*DetachNetworkinterface) DryRun

func (cmd *DetachNetworkinterface) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachNetworkinterface) ManualRun

func (cmd *DetachNetworkinterface) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachNetworkinterface) ParamsHelp

func (cmd *DetachNetworkinterface) ParamsHelp() string

func (*DetachNetworkinterface) Run

func (cmd *DetachNetworkinterface) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachNetworkinterface) SetApi

func (cmd *DetachNetworkinterface) SetApi(api ec2iface.EC2API)

func (*DetachNetworkinterface) ValidateCommand

func (cmd *DetachNetworkinterface) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachNetworkinterface) ValidateParams

func (cmd *DetachNetworkinterface) ValidateParams(params []string) ([]string, error)

type DetachPolicy

type DetachPolicy struct {
	Arn   *string `awsName:"PolicyArn" awsType:"awsstr" templateName:"arn"`
	User  *string `awsName:"UserName" awsType:"awsstr" templateName:"user"`
	Group *string `awsName:"GroupName" awsType:"awsstr" templateName:"group"`
	Role  *string `awsName:"RoleName" awsType:"awsstr" templateName:"role"`
	// contains filtered or unexported fields
}

func NewDetachPolicy

func NewDetachPolicy(sess *session.Session, l ...*logger.Logger) *DetachPolicy

func (*DetachPolicy) ConvertParams

func (cmd *DetachPolicy) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]interface{}, error))

func (*DetachPolicy) DryRun

func (cmd *DetachPolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachPolicy) ManualRun

func (cmd *DetachPolicy) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachPolicy) ParamsHelp

func (cmd *DetachPolicy) ParamsHelp() string

func (*DetachPolicy) Run

func (cmd *DetachPolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachPolicy) SetApi

func (cmd *DetachPolicy) SetApi(api iamiface.IAMAPI)

func (*DetachPolicy) ValidateCommand

func (cmd *DetachPolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachPolicy) ValidateParams

func (cmd *DetachPolicy) ValidateParams(params []string) ([]string, error)

type DetachRole

type DetachRole struct {
	Instanceprofile *string `awsName:"InstanceProfileName" awsType:"awsstr" templateName:"instanceprofile" required:""`
	Name            *string `awsName:"RoleName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDetachRole

func NewDetachRole(sess *session.Session, l ...*logger.Logger) *DetachRole

func (*DetachRole) DryRun

func (cmd *DetachRole) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRole) ParamsHelp

func (cmd *DetachRole) ParamsHelp() string

func (*DetachRole) Run

func (cmd *DetachRole) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRole) SetApi

func (cmd *DetachRole) SetApi(api iamiface.IAMAPI)

func (*DetachRole) ValidateCommand

func (cmd *DetachRole) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachRole) ValidateParams

func (cmd *DetachRole) ValidateParams(params []string) ([]string, error)

type DetachRoutetable

type DetachRoutetable struct {
	Association *string `awsName:"AssociationId" awsType:"awsstr" templateName:"association" required:""`
	// contains filtered or unexported fields
}

func NewDetachRoutetable

func NewDetachRoutetable(sess *session.Session, l ...*logger.Logger) *DetachRoutetable

func (*DetachRoutetable) DryRun

func (cmd *DetachRoutetable) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRoutetable) ParamsHelp

func (cmd *DetachRoutetable) ParamsHelp() string

func (*DetachRoutetable) Run

func (cmd *DetachRoutetable) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRoutetable) SetApi

func (cmd *DetachRoutetable) SetApi(api ec2iface.EC2API)

func (*DetachRoutetable) ValidateCommand

func (cmd *DetachRoutetable) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachRoutetable) ValidateParams

func (cmd *DetachRoutetable) ValidateParams(params []string) ([]string, error)

type DetachSecuritygroup

type DetachSecuritygroup struct {
	Id       *string `templateName:"id" required:""`
	Instance *string `templateName:"instance" required:""`
	// contains filtered or unexported fields
}

func NewDetachSecuritygroup

func NewDetachSecuritygroup(sess *session.Session, l ...*logger.Logger) *DetachSecuritygroup

func (*DetachSecuritygroup) DryRun

func (cmd *DetachSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachSecuritygroup) ManualRun

func (cmd *DetachSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachSecuritygroup) ParamsHelp

func (cmd *DetachSecuritygroup) ParamsHelp() string

func (*DetachSecuritygroup) Run

func (cmd *DetachSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachSecuritygroup) SetApi

func (cmd *DetachSecuritygroup) SetApi(api ec2iface.EC2API)

func (*DetachSecuritygroup) ValidateCommand

func (cmd *DetachSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachSecuritygroup) ValidateParams

func (cmd *DetachSecuritygroup) ValidateParams(params []string) ([]string, error)

type DetachUser

type DetachUser struct {
	Group *string `awsName:"GroupName" awsType:"awsstr" templateName:"group" required:""`
	Name  *string `awsName:"UserName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDetachUser

func NewDetachUser(sess *session.Session, l ...*logger.Logger) *DetachUser

func (*DetachUser) DryRun

func (cmd *DetachUser) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachUser) ParamsHelp

func (cmd *DetachUser) ParamsHelp() string

func (*DetachUser) Run

func (cmd *DetachUser) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachUser) SetApi

func (cmd *DetachUser) SetApi(api iamiface.IAMAPI)

func (*DetachUser) ValidateCommand

func (cmd *DetachUser) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachUser) ValidateParams

func (cmd *DetachUser) ValidateParams(params []string) ([]string, error)

type DetachVolume

type DetachVolume struct {
	Device   *string `awsName:"Device" awsType:"awsstr" templateName:"device" required:""`
	Id       *string `awsName:"VolumeId" awsType:"awsstr" templateName:"id" required:""`
	Instance *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance" required:""`
	Force    *bool   `awsName:"Force" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDetachVolume

func NewDetachVolume(sess *session.Session, l ...*logger.Logger) *DetachVolume

func (*DetachVolume) DryRun

func (cmd *DetachVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachVolume) ExtractResult

func (cmd *DetachVolume) ExtractResult(i interface{}) string

func (*DetachVolume) ParamsHelp

func (cmd *DetachVolume) ParamsHelp() string

func (*DetachVolume) Run

func (cmd *DetachVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachVolume) SetApi

func (cmd *DetachVolume) SetApi(api ec2iface.EC2API)

func (*DetachVolume) ValidateCommand

func (cmd *DetachVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachVolume) ValidateParams

func (cmd *DetachVolume) ValidateParams(params []string) ([]string, error)

type Factory

type Factory interface {
	Build(key string) func() interface{}
}
var CommandFactory Factory

type ImportImage

type ImportImage struct {
	Architecture *string `awsName:"Architecture" awsType:"awsstr" templateName:"architecture"`
	Description  *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	License      *string `awsName:"LicenseType" awsType:"awsstr" templateName:"license"`
	Platform     *string `awsName:"Platform" awsType:"awsstr" templateName:"platform"`
	Role         *string `awsName:"RoleName" awsType:"awsstr" templateName:"role"`
	Snapshot     *string `awsName:"DiskContainers[0]SnapshotId" awsType:"awsslicestruct" templateName:"snapshot"`
	Url          *string `awsName:"DiskContainers[0]Url" awsType:"awsslicestruct" templateName:"url"`
	Bucket       *string `awsName:"DiskContainers[0]UserBucket.S3Bucket" awsType:"awsslicestruct" templateName:"bucket"`
	S3object     *string `awsName:"DiskContainers[0]UserBucket.S3Key" awsType:"awsslicestruct" templateName:"s3object"`
	// contains filtered or unexported fields
}

func NewImportImage

func NewImportImage(sess *session.Session, l ...*logger.Logger) *ImportImage

func (*ImportImage) DryRun

func (cmd *ImportImage) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*ImportImage) ExtractResult

func (cmd *ImportImage) ExtractResult(i interface{}) string

func (*ImportImage) ParamsHelp

func (cmd *ImportImage) ParamsHelp() string

func (*ImportImage) Run

func (cmd *ImportImage) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*ImportImage) SetApi

func (cmd *ImportImage) SetApi(api ec2iface.EC2API)

func (*ImportImage) ValidateCommand

func (cmd *ImportImage) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*ImportImage) ValidateParams

func (cmd *ImportImage) ValidateParams(params []string) ([]string, error)

type ProgressReadSeeker

type ProgressReadSeeker struct {
	// contains filtered or unexported fields
}

func NewProgressReader

func NewProgressReader(f *os.File) (*ProgressReadSeeker, error)

func (*ProgressReadSeeker) Read

func (pr *ProgressReadSeeker) Read(p []byte) (int, error)

func (*ProgressReadSeeker) Seek

func (pr *ProgressReadSeeker) Seek(offset int64, whence int) (int64, error)

type ResultExtractor

type ResultExtractor interface {
	ExtractResult(interface{}) string
}

type StartAlarm

type StartAlarm struct {
	Names []*string `awsName:"AlarmNames" awsType:"awsstringslice" templateName:"names" required:""`
	// contains filtered or unexported fields
}

func NewStartAlarm

func NewStartAlarm(sess *session.Session, l ...*logger.Logger) *StartAlarm

func (*StartAlarm) DryRun

func (cmd *StartAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StartAlarm) ParamsHelp

func (cmd *StartAlarm) ParamsHelp() string

func (*StartAlarm) Run

func (cmd *StartAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StartAlarm) SetApi

func (cmd *StartAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*StartAlarm) ValidateCommand

func (cmd *StartAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StartAlarm) ValidateParams

func (cmd *StartAlarm) ValidateParams(params []string) ([]string, error)

type StartContainertask

type StartContainertask struct {
	Cluster                   *string `templateName:"cluster" required:""`
	DesiredCount              *int64  `templateName:"desired-count" required:""`
	Name                      *string `templateName:"name" required:""`
	Type                      *string `templateName:"type" required:""`
	Role                      *string `templateName:"role"`
	DeploymentName            *string `templateName:"deployment-name"`
	LoadBalancerContainerName *string `templateName:"loadbalancer.container-name"`
	LoadBalancerContainerPort *int64  `templateName:"loadbalancer.container-port"`
	LoadBalancerTargetgroup   *string `templateName:"loadbalancer.targetgroup"`
	// contains filtered or unexported fields
}

func NewStartContainertask

func NewStartContainertask(sess *session.Session, l ...*logger.Logger) *StartContainertask

func (*StartContainertask) DryRun

func (cmd *StartContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StartContainertask) ExtractResult

func (cmd *StartContainertask) ExtractResult(i interface{}) string

func (*StartContainertask) ManualRun

func (cmd *StartContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*StartContainertask) ParamsHelp

func (cmd *StartContainertask) ParamsHelp() string

func (*StartContainertask) Run

func (cmd *StartContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StartContainertask) SetApi

func (cmd *StartContainertask) SetApi(api ecsiface.ECSAPI)

func (*StartContainertask) ValidateCommand

func (cmd *StartContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StartContainertask) ValidateParams

func (cmd *StartContainertask) ValidateParams(params []string) ([]string, error)

func (*StartContainertask) Validate_Type

func (cmd *StartContainertask) Validate_Type() error

type StartInstance

type StartInstance struct {
	Id []*string `awsName:"InstanceIds" awsType:"awsstringslice" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewStartInstance

func NewStartInstance(sess *session.Session, l ...*logger.Logger) *StartInstance

func (*StartInstance) DryRun

func (cmd *StartInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StartInstance) ExtractResult

func (cmd *StartInstance) ExtractResult(i interface{}) string

func (*StartInstance) ParamsHelp

func (cmd *StartInstance) ParamsHelp() string

func (*StartInstance) Run

func (cmd *StartInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StartInstance) SetApi

func (cmd *StartInstance) SetApi(api ec2iface.EC2API)

func (*StartInstance) ValidateCommand

func (cmd *StartInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StartInstance) ValidateParams

func (cmd *StartInstance) ValidateParams(params []string) ([]string, error)

type StopAlarm

type StopAlarm struct {
	Names []*string `awsName:"AlarmNames" awsType:"awsstringslice" templateName:"names" required:""`
	// contains filtered or unexported fields
}

func NewStopAlarm

func NewStopAlarm(sess *session.Session, l ...*logger.Logger) *StopAlarm

func (*StopAlarm) DryRun

func (cmd *StopAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StopAlarm) ParamsHelp

func (cmd *StopAlarm) ParamsHelp() string

func (*StopAlarm) Run

func (cmd *StopAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StopAlarm) SetApi

func (cmd *StopAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*StopAlarm) ValidateCommand

func (cmd *StopAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StopAlarm) ValidateParams

func (cmd *StopAlarm) ValidateParams(params []string) ([]string, error)

type StopContainertask

type StopContainertask struct {
	Cluster        *string `templateName:"cluster" required:""`
	Type           *string `templateName:"type" required:""`
	DeploymentName *string `templateName:"deployment-name"`
	RunArn         *string `templateName:"run-arn"`
	// contains filtered or unexported fields
}

func NewStopContainertask

func NewStopContainertask(sess *session.Session, l ...*logger.Logger) *StopContainertask

func (*StopContainertask) DryRun

func (cmd *StopContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StopContainertask) ManualRun

func (cmd *StopContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*StopContainertask) ParamsHelp

func (cmd *StopContainertask) ParamsHelp() string

func (*StopContainertask) Run

func (cmd *StopContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StopContainertask) SetApi

func (cmd *StopContainertask) SetApi(api ecsiface.ECSAPI)

func (*StopContainertask) ValidateCommand

func (cmd *StopContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StopContainertask) ValidateParams

func (cmd *StopContainertask) ValidateParams(params []string) ([]string, error)

func (*StopContainertask) Validate_Type

func (cmd *StopContainertask) Validate_Type() error

type StopInstance

type StopInstance struct {
	Id []*string `awsName:"InstanceIds" awsType:"awsstringslice" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewStopInstance

func NewStopInstance(sess *session.Session, l ...*logger.Logger) *StopInstance

func (*StopInstance) DryRun

func (cmd *StopInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StopInstance) ExtractResult

func (cmd *StopInstance) ExtractResult(i interface{}) string

func (*StopInstance) ParamsHelp

func (cmd *StopInstance) ParamsHelp() string

func (*StopInstance) Run

func (cmd *StopInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StopInstance) SetApi

func (cmd *StopInstance) SetApi(api ec2iface.EC2API)

func (*StopInstance) ValidateCommand

func (cmd *StopInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StopInstance) ValidateParams

func (cmd *StopInstance) ValidateParams(params []string) ([]string, error)

type UpdateBucket

type UpdateBucket struct {
	Name             *string `templateName:"name" required:""`
	Acl              *string `templateName:"acl"`
	PublicWebsite    *bool   `templateName:"public-website"`
	RedirectHostname *string `templateName:"redirect-hostname"`
	IndexSuffix      *string `templateName:"index-suffix"`
	EnforceHttps     *bool   `templateName:"enforce-https"`
	// contains filtered or unexported fields
}

func NewUpdateBucket

func NewUpdateBucket(sess *session.Session, l ...*logger.Logger) *UpdateBucket

func (*UpdateBucket) DryRun

func (cmd *UpdateBucket) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateBucket) ManualRun

func (cmd *UpdateBucket) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateBucket) ParamsHelp

func (cmd *UpdateBucket) ParamsHelp() string

func (*UpdateBucket) Run

func (cmd *UpdateBucket) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateBucket) SetApi

func (cmd *UpdateBucket) SetApi(api s3iface.S3API)

func (*UpdateBucket) ValidateCommand

func (cmd *UpdateBucket) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateBucket) ValidateParams

func (cmd *UpdateBucket) ValidateParams(params []string) ([]string, error)

type UpdateContainertask

type UpdateContainertask struct {
	Cluster        *string `awsName:"Cluster" awsType:"awsstr" templateName:"cluster" required:""`
	DeploymentName *string `awsName:"Service" awsType:"awsstr" templateName:"deployment-name" required:""`
	DesiredCount   *int64  `awsName:"DesiredCount" awsType:"awsint64" templateName:"desired-count"`
	Name           *string `awsName:"TaskDefinition" awsType:"awsstr" templateName:"name"`
	// contains filtered or unexported fields
}

func NewUpdateContainertask

func NewUpdateContainertask(sess *session.Session, l ...*logger.Logger) *UpdateContainertask

func (*UpdateContainertask) DryRun

func (cmd *UpdateContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateContainertask) ParamsHelp

func (cmd *UpdateContainertask) ParamsHelp() string

func (*UpdateContainertask) Run

func (cmd *UpdateContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateContainertask) SetApi

func (cmd *UpdateContainertask) SetApi(api ecsiface.ECSAPI)

func (*UpdateContainertask) ValidateCommand

func (cmd *UpdateContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateContainertask) ValidateParams

func (cmd *UpdateContainertask) ValidateParams(params []string) ([]string, error)

type UpdateDistribution

type UpdateDistribution struct {
	Id     *string `awsName:"Id" awsType:"awsstr" templateName:"id" required:""`
	Enable *bool   `awsName:"DistributionConfig.Enabled" awsType:"awsbool" templateName:"enable" required:""`
	// contains filtered or unexported fields
}

func NewUpdateDistribution

func NewUpdateDistribution(sess *session.Session, l ...*logger.Logger) *UpdateDistribution

func (*UpdateDistribution) DryRun

func (cmd *UpdateDistribution) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateDistribution) ExtractResult

func (cmd *UpdateDistribution) ExtractResult(i interface{}) string

func (*UpdateDistribution) ManualRun

func (cmd *UpdateDistribution) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateDistribution) ParamsHelp

func (cmd *UpdateDistribution) ParamsHelp() string

func (*UpdateDistribution) Run

func (cmd *UpdateDistribution) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateDistribution) SetApi

func (*UpdateDistribution) ValidateCommand

func (cmd *UpdateDistribution) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateDistribution) ValidateParams

func (cmd *UpdateDistribution) ValidateParams(params []string) ([]string, error)

type UpdateInstance

type UpdateInstance struct {
	Id   *string `awsName:"InstanceId" awsType:"awsstr" templateName:"id" required:""`
	Type *string `awsName:"InstanceType.Value" awsType:"awsstr" templateName:"type"`
	Lock *bool   `awsName:"DisableApiTermination" awsType:"awsboolattribute" templateName:"lock"`
	// contains filtered or unexported fields
}

func NewUpdateInstance

func NewUpdateInstance(sess *session.Session, l ...*logger.Logger) *UpdateInstance

func (*UpdateInstance) DryRun

func (cmd *UpdateInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateInstance) ParamsHelp

func (cmd *UpdateInstance) ParamsHelp() string

func (*UpdateInstance) Run

func (cmd *UpdateInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateInstance) SetApi

func (cmd *UpdateInstance) SetApi(api ec2iface.EC2API)

func (*UpdateInstance) ValidateCommand

func (cmd *UpdateInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateInstance) ValidateParams

func (cmd *UpdateInstance) ValidateParams(params []string) ([]string, error)

type UpdateLoginprofile

type UpdateLoginprofile struct {
	Username      *string `awsName:"UserName" awsType:"awsstr" templateName:"username" required:""`
	Password      *string `awsName:"Password" awsType:"awsstr" templateName:"password" required:""`
	PasswordReset *bool   `awsName:"PasswordResetRequired" awsType:"awsbool" templateName:"password-reset"`
	// contains filtered or unexported fields
}

func NewUpdateLoginprofile

func NewUpdateLoginprofile(sess *session.Session, l ...*logger.Logger) *UpdateLoginprofile

func (*UpdateLoginprofile) DryRun

func (cmd *UpdateLoginprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateLoginprofile) ParamsHelp

func (cmd *UpdateLoginprofile) ParamsHelp() string

func (*UpdateLoginprofile) Run

func (cmd *UpdateLoginprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateLoginprofile) SetApi

func (cmd *UpdateLoginprofile) SetApi(api iamiface.IAMAPI)

func (*UpdateLoginprofile) ValidateCommand

func (cmd *UpdateLoginprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateLoginprofile) ValidateParams

func (cmd *UpdateLoginprofile) ValidateParams(params []string) ([]string, error)

type UpdatePolicy

type UpdatePolicy struct {
	Arn            *string   `awsName:"PolicyArn" awsType:"awsstr" templateName:"arn" required:""`
	Effect         *string   `templateName:"effect" required:""`
	Action         []*string `templateName:"action" required:""`
	Resource       []*string `templateName:"resource" required:""`
	Conditions     []*string `templateName:"conditions"`
	Document       *string   `awsName:"PolicyDocument" awsType:"awsstr"`
	DefaultVersion *bool     `awsName:"SetAsDefault" awsType:"awsbool"`
	// contains filtered or unexported fields
}

func NewUpdatePolicy

func NewUpdatePolicy(sess *session.Session, l ...*logger.Logger) *UpdatePolicy

func (*UpdatePolicy) BeforeRun

func (cmd *UpdatePolicy) BeforeRun(ctx map[string]interface{}) error

func (*UpdatePolicy) DryRun

func (cmd *UpdatePolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdatePolicy) ParamsHelp

func (cmd *UpdatePolicy) ParamsHelp() string

func (*UpdatePolicy) Run

func (cmd *UpdatePolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdatePolicy) SetApi

func (cmd *UpdatePolicy) SetApi(api iamiface.IAMAPI)

func (*UpdatePolicy) ValidateCommand

func (cmd *UpdatePolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdatePolicy) ValidateParams

func (cmd *UpdatePolicy) ValidateParams(params []string) ([]string, error)

type UpdateRecord

type UpdateRecord struct {
	Zone  *string `templateName:"zone" required:""`
	Name  *string `templateName:"name" required:""`
	Type  *string `templateName:"type" required:""`
	Value *string `templateName:"value" required:""`
	Ttl   *int64  `templateName:"ttl" required:""`
	// contains filtered or unexported fields
}

func NewUpdateRecord

func NewUpdateRecord(sess *session.Session, l ...*logger.Logger) *UpdateRecord

func (*UpdateRecord) DryRun

func (cmd *UpdateRecord) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateRecord) ExtractResult

func (cmd *UpdateRecord) ExtractResult(i interface{}) string

func (*UpdateRecord) ManualRun

func (cmd *UpdateRecord) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateRecord) ParamsHelp

func (cmd *UpdateRecord) ParamsHelp() string

func (*UpdateRecord) Run

func (cmd *UpdateRecord) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateRecord) SetApi

func (cmd *UpdateRecord) SetApi(api route53iface.Route53API)

func (*UpdateRecord) ValidateCommand

func (cmd *UpdateRecord) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateRecord) ValidateParams

func (cmd *UpdateRecord) ValidateParams(params []string) ([]string, error)

type UpdateS3object

type UpdateS3object struct {
	Bucket  *string `awsName:"Bucket" awsType:"awsstr" templateName:"bucket" required:""`
	Name    *string `awsName:"Key" awsType:"awsstr" templateName:"name" required:""`
	Acl     *string `awsName:"ACL" awsType:"awsstr" templateName:"acl" required:""`
	Version *string `awsName:"VersionId" awsType:"awsstr" templateName:"version"`
	// contains filtered or unexported fields
}

func NewUpdateS3object

func NewUpdateS3object(sess *session.Session, l ...*logger.Logger) *UpdateS3object

func (*UpdateS3object) DryRun

func (cmd *UpdateS3object) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateS3object) ParamsHelp

func (cmd *UpdateS3object) ParamsHelp() string

func (*UpdateS3object) Run

func (cmd *UpdateS3object) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateS3object) SetApi

func (cmd *UpdateS3object) SetApi(api s3iface.S3API)

func (*UpdateS3object) ValidateCommand

func (cmd *UpdateS3object) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateS3object) ValidateParams

func (cmd *UpdateS3object) ValidateParams(params []string) ([]string, error)

type UpdateScalinggroup

type UpdateScalinggroup struct {
	Name                   *string   `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name" required:""`
	Cooldown               *int64    `awsName:"DefaultCooldown" awsType:"awsint64" templateName:"cooldown"`
	DesiredCapacity        *int64    `awsName:"DesiredCapacity" awsType:"awsint64" templateName:"desired-capacity"`
	HealthcheckGracePeriod *int64    `awsName:"HealthCheckGracePeriod" awsType:"awsint64" templateName:"healthcheck-grace-period"`
	HealthcheckType        *string   `awsName:"HealthCheckType" awsType:"awsstr" templateName:"healthcheck-type"`
	Launchconfiguration    *string   `awsName:"LaunchConfigurationName" awsType:"awsstr" templateName:"launchconfiguration"`
	MaxSize                *int64    `awsName:"MaxSize" awsType:"awsint64" templateName:"max-size"`
	MinSize                *int64    `awsName:"MinSize" awsType:"awsint64" templateName:"min-size"`
	NewInstancesProtected  *bool     `awsName:"NewInstancesProtectedFromScaleIn" awsType:"awsbool" templateName:"new-instances-protected"`
	Subnets                []*string `awsName:"VPCZoneIdentifier" awsType:"awscsvstr" templateName:"subnets"`
	// contains filtered or unexported fields
}

func NewUpdateScalinggroup

func NewUpdateScalinggroup(sess *session.Session, l ...*logger.Logger) *UpdateScalinggroup

func (*UpdateScalinggroup) DryRun

func (cmd *UpdateScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateScalinggroup) ParamsHelp

func (cmd *UpdateScalinggroup) ParamsHelp() string

func (*UpdateScalinggroup) Run

func (cmd *UpdateScalinggroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateScalinggroup) SetApi

func (*UpdateScalinggroup) ValidateCommand

func (cmd *UpdateScalinggroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateScalinggroup) ValidateParams

func (cmd *UpdateScalinggroup) ValidateParams(params []string) ([]string, error)

type UpdateSecuritygroup

type UpdateSecuritygroup struct {
	Id            *string `templateName:"id" required:""`
	Protocol      *string `templateName:"protocol" required:""`
	CIDR          *string `templateName:"cidr"`
	Securitygroup *string `templateName:"securitygroup"`
	Inbound       *string `templateName:"inbound"`
	Outbound      *string `templateName:"outbound"`
	Portrange     *string `templateName:"portrange"`
	// contains filtered or unexported fields
}

func NewUpdateSecuritygroup

func NewUpdateSecuritygroup(sess *session.Session, l ...*logger.Logger) *UpdateSecuritygroup

func (*UpdateSecuritygroup) DryRun

func (cmd *UpdateSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSecuritygroup) ManualRun

func (cmd *UpdateSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateSecuritygroup) ParamsHelp

func (cmd *UpdateSecuritygroup) ParamsHelp() string

func (*UpdateSecuritygroup) Run

func (cmd *UpdateSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSecuritygroup) SetApi

func (cmd *UpdateSecuritygroup) SetApi(api ec2iface.EC2API)

func (*UpdateSecuritygroup) ValidateCommand

func (cmd *UpdateSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateSecuritygroup) ValidateParams

func (cmd *UpdateSecuritygroup) ValidateParams(params []string) ([]string, error)

func (*UpdateSecuritygroup) Validate_CIDR

func (cmd *UpdateSecuritygroup) Validate_CIDR() error

func (*UpdateSecuritygroup) Validate_Inbound

func (cmd *UpdateSecuritygroup) Validate_Inbound() error

func (*UpdateSecuritygroup) Validate_Outbound

func (cmd *UpdateSecuritygroup) Validate_Outbound() error

type UpdateStack

type UpdateStack struct {
	Name                *string   `awsName:"StackName" awsType:"awsstr" templateName:"name" required:""`
	Capabilities        []*string `awsName:"Capabilities" awsType:"awsstringslice" templateName:"capabilities"`
	Notifications       []*string `awsName:"NotificationARNs" awsType:"awsstringslice" templateName:"notifications"`
	Parameters          []*string `awsName:"Parameters" awsType:"awsparameterslice" templateName:"parameters"`
	ResourceTypes       []*string `awsName:"ResourceTypes" awsType:"awsstringslice" templateName:"resource-types"`
	Role                *string   `awsName:"RoleARN" awsType:"awsstr" templateName:"role"`
	PolicyFile          *string   `awsName:"StackPolicyBody" awsType:"awsfiletostring" templateName:"policy-file"`
	PolicyUpdateFile    *string   `awsName:"StackPolicyDuringUpdateBody" awsType:"awsfiletostring" templateName:"policy-update-file"`
	TemplateFile        *string   `awsName:"TemplateBody" awsType:"awsfiletostring" templateName:"template-file"`
	UsePreviousTemplate *bool     `awsName:"UsePreviousTemplate" awsType:"awsbool" templateName:"use-previous-template"`
	// contains filtered or unexported fields
}

func NewUpdateStack

func NewUpdateStack(sess *session.Session, l ...*logger.Logger) *UpdateStack

func (*UpdateStack) DryRun

func (cmd *UpdateStack) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateStack) ExtractResult

func (cmd *UpdateStack) ExtractResult(i interface{}) string

func (*UpdateStack) ParamsHelp

func (cmd *UpdateStack) ParamsHelp() string

func (*UpdateStack) Run

func (cmd *UpdateStack) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateStack) SetApi

func (*UpdateStack) ValidateCommand

func (cmd *UpdateStack) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateStack) ValidateParams

func (cmd *UpdateStack) ValidateParams(params []string) ([]string, error)

type UpdateSubnet

type UpdateSubnet struct {
	Id     *string `awsName:"SubnetId" awsType:"awsstr" templateName:"id" required:""`
	Public *bool   `awsName:"MapPublicIpOnLaunch" awsType:"awsboolattribute" templateName:"public"`
	// contains filtered or unexported fields
}

func NewUpdateSubnet

func NewUpdateSubnet(sess *session.Session, l ...*logger.Logger) *UpdateSubnet

func (*UpdateSubnet) DryRun

func (cmd *UpdateSubnet) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSubnet) ParamsHelp

func (cmd *UpdateSubnet) ParamsHelp() string

func (*UpdateSubnet) Run

func (cmd *UpdateSubnet) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSubnet) SetApi

func (cmd *UpdateSubnet) SetApi(api ec2iface.EC2API)

func (*UpdateSubnet) ValidateCommand

func (cmd *UpdateSubnet) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateSubnet) ValidateParams

func (cmd *UpdateSubnet) ValidateParams(params []string) ([]string, error)

type UpdateTargetgroup

type UpdateTargetgroup struct {
	Id                  *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"id" required:""`
	Deregistrationdelay *string `awsType:"awsstr" templateName:"deregistrationdelay"`
	Stickiness          *string `awsType:"awsstr" templateName:"stickiness"`
	Stickinessduration  *string `awsType:"awsstr" templateName:"stickinessduration"`
	Healthcheckinterval *int64  `awsName:"HealthCheckIntervalSeconds" awsType:"awsint64" templateName:"healthcheckinterval"`
	Healthcheckpath     *string `awsName:"HealthCheckPath" awsType:"awsstr" templateName:"healthcheckpath"`
	Healthcheckport     *string `awsName:"HealthCheckPort" awsType:"awsstr" templateName:"healthcheckport"`
	Healthcheckprotocol *string `awsName:"HealthCheckProtocol" awsType:"awsstr" templateName:"healthcheckprotocol"`
	Healthchecktimeout  *int64  `awsName:"HealthCheckTimeoutSeconds" awsType:"awsint64" templateName:"healthchecktimeout"`
	Healthythreshold    *int64  `awsName:"HealthyThresholdCount" awsType:"awsint64" templateName:"healthythreshold"`
	Unhealthythreshold  *int64  `awsName:"UnhealthyThresholdCount" awsType:"awsint64" templateName:"unhealthythreshold"`
	Matcher             *string `awsName:"Matcher.HttpCode" awsType:"awsstr" templateName:"matcher"`
	// contains filtered or unexported fields
}

func NewUpdateTargetgroup

func NewUpdateTargetgroup(sess *session.Session, l ...*logger.Logger) *UpdateTargetgroup

func (*UpdateTargetgroup) DryRun

func (cmd *UpdateTargetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateTargetgroup) ManualRun

func (tg *UpdateTargetgroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateTargetgroup) ParamsHelp

func (cmd *UpdateTargetgroup) ParamsHelp() string

func (*UpdateTargetgroup) Run

func (cmd *UpdateTargetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateTargetgroup) SetApi

func (cmd *UpdateTargetgroup) SetApi(api elbv2iface.ELBV2API)

func (*UpdateTargetgroup) ValidateCommand

func (cmd *UpdateTargetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateTargetgroup) ValidateParams

func (cmd *UpdateTargetgroup) ValidateParams(params []string) ([]string, error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL