awsspec

package

Go to main page

Versions in this module

v0

v0.1.11

Jun 21, 2018

Changes in this version

+ type AttachClassicLoadbalancer struct

+ Instance *string

+ Name *string

+ func NewAttachClassicLoadbalancer(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *AttachClassicLoadbalancer

+ func (cmd *AttachClassicLoadbalancer) ExtractResult(interface{}) string

+ func (cmd *AttachClassicLoadbalancer) ParamsSpec() params.Spec

+ func (cmd *AttachClassicLoadbalancer) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *AttachClassicLoadbalancer) SetApi(api elbiface.ELBAPI)

+ type CreateClassicLoadbalancer struct

+ AvailabilityZones []*string

+ HealthCheckPathToPing string

+ Listeners []*string

+ Name *string

+ Scheme *string

+ Securitygroups []*string

+ Subnets []*string

+ Tags []*string

+ func NewCreateClassicLoadbalancer(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *CreateClassicLoadbalancer

+ func (cmd *CreateClassicLoadbalancer) AfterRun(renv env.Running, output interface{}) (err error)

+ func (cmd *CreateClassicLoadbalancer) ExtractResult(i interface{}) string

+ func (cmd *CreateClassicLoadbalancer) ParamsSpec() params.Spec

+ func (cmd *CreateClassicLoadbalancer) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *CreateClassicLoadbalancer) SetApi(api elbiface.ELBAPI)

+ type DeleteClassicLoadbalancer struct

+ Name *string

+ func NewDeleteClassicLoadbalancer(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *DeleteClassicLoadbalancer

+ func (cmd *DeleteClassicLoadbalancer) ParamsSpec() params.Spec

+ func (cmd *DeleteClassicLoadbalancer) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *DeleteClassicLoadbalancer) SetApi(api elbiface.ELBAPI)

+ type DetachClassicLoadbalancer struct

+ Instance *string

+ Name *string

+ func NewDetachClassicLoadbalancer(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *DetachClassicLoadbalancer

+ func (cmd *DetachClassicLoadbalancer) ExtractResult(interface{}) string

+ func (cmd *DetachClassicLoadbalancer) ParamsSpec() params.Spec

+ func (cmd *DetachClassicLoadbalancer) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachClassicLoadbalancer) SetApi(api elbiface.ELBAPI)

+ type UpdateClassicLoadbalancer struct

+ HealthcheckHealthyThreshold *int64

+ HealthcheckInterval *int64

+ HealthcheckTarget *string

+ HealthcheckTimeout *int64

+ HealthcheckUnhealthyThreshold *int64

+ Name *string

+ func NewUpdateClassicLoadbalancer(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *UpdateClassicLoadbalancer

+ func (cmd *UpdateClassicLoadbalancer) ParamsSpec() params.Spec

+ func (cmd *UpdateClassicLoadbalancer) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateClassicLoadbalancer) SetApi(api elbiface.ELBAPI)

v0.1.10

Apr 13, 2018

Changes in this version

+ var CentOS = Platform

+ var CoreOS = Platform

+ type AttachListener struct

+ Certificate *string

+ Id *string

+ func NewAttachListener(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *AttachListener

+ func (cmd *AttachListener) ParamsSpec() params.Spec

+ func (cmd *AttachListener) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *AttachListener) SetApi(api elbv2iface.ELBV2API)

type CreateStack

+ RollbackMonitoringMin *int64

+ RollbackTriggers []*string

type UpdateStack

+ RollbackMonitoringMin *int64

+ RollbackTriggers []*string

v0.1.9

Jan 16, 2018

Changes in this version

type AWSFactory

+ Graph cloud.GraphAPI

type AttachAlarm

+ func (cmd *AttachAlarm) ParamsSpec() params.Spec

type AttachContainertask

+ func (cmd *AttachContainertask) ParamsSpec() params.Spec

type AttachElasticip

+ func (cmd *AttachElasticip) ParamsSpec() params.Spec

type AttachInstance

+ func (cmd *AttachInstance) ParamsSpec() params.Spec

type AttachInstanceprofile

+ func (cmd *AttachInstanceprofile) ParamsSpec() params.Spec

type AttachInternetgateway

+ func (cmd *AttachInternetgateway) ParamsSpec() params.Spec

type AttachMfadevice

+ func (cmd *AttachMfadevice) ParamsSpec() params.Spec

type AttachNetworkinterface

+ func (cmd *AttachNetworkinterface) ParamsSpec() params.Spec

type AttachPolicy

+ func (cmd *AttachPolicy) ParamsSpec() params.Spec

type AttachRole

+ func (cmd *AttachRole) ParamsSpec() params.Spec

type AttachRoutetable

+ func (cmd *AttachRoutetable) ParamsSpec() params.Spec

type AttachSecuritygroup

+ func (cmd *AttachSecuritygroup) ParamsSpec() params.Spec

type AttachUser

+ func (cmd *AttachUser) ParamsSpec() params.Spec

type AttachVolume

+ func (cmd *AttachVolume) ParamsSpec() params.Spec

type AuthenticateRegistry

+ func (cmd *AuthenticateRegistry) ParamsSpec() params.Spec

type CheckCertificate

+ func (cmd *CheckCertificate) ParamsSpec() params.Spec

type CheckDatabase

+ func (cmd *CheckDatabase) ParamsSpec() params.Spec

type CheckDistribution

+ func (cmd *CheckDistribution) ParamsSpec() params.Spec

type CheckInstance

+ func (cmd *CheckInstance) ParamsSpec() params.Spec

type CheckLoadbalancer

+ func (cmd *CheckLoadbalancer) ParamsSpec() params.Spec

type CheckNatgateway

+ func (cmd *CheckNatgateway) ParamsSpec() params.Spec

type CheckNetworkinterface

+ func (cmd *CheckNetworkinterface) ParamsSpec() params.Spec

type CheckScalinggroup

+ func (cmd *CheckScalinggroup) ParamsSpec() params.Spec

type CheckSecuritygroup

+ func (cmd *CheckSecuritygroup) ParamsSpec() params.Spec

type CheckVolume

+ func (cmd *CheckVolume) ParamsSpec() params.Spec

type CopyImage

+ func (cmd *CopyImage) ParamsSpec() params.Spec

type CopySnapshot

+ func (cmd *CopySnapshot) ParamsSpec() params.Spec

type CreateAccesskey

+ func (cmd *CreateAccesskey) ParamsSpec() params.Spec

type CreateAlarm

+ func (cmd *CreateAlarm) ParamsSpec() params.Spec

type CreateAppscalingpolicy

+ func (cmd *CreateAppscalingpolicy) ParamsSpec() params.Spec

type CreateAppscalingtarget

+ func (cmd *CreateAppscalingtarget) ParamsSpec() params.Spec

type CreateBucket

+ func (cmd *CreateBucket) ParamsSpec() params.Spec

type CreateCertificate

+ func (cmd *CreateCertificate) ParamsSpec() params.Spec

type CreateContainercluster

+ func (cmd *CreateContainercluster) ParamsSpec() params.Spec

type CreateDatabase

+ func (cmd *CreateDatabase) ParamsSpec() params.Spec

type CreateDbsubnetgroup

+ func (cmd *CreateDbsubnetgroup) ParamsSpec() params.Spec

type CreateDistribution

+ func (cmd *CreateDistribution) ParamsSpec() params.Spec

type CreateElasticip

+ func (cmd *CreateElasticip) ParamsSpec() params.Spec

type CreateFunction

+ func (cmd *CreateFunction) ParamsSpec() params.Spec

type CreateGroup

+ func (cmd *CreateGroup) ParamsSpec() params.Spec

+ type CreateImage struct

+ Description *string

+ Instance *string

+ Name *string

+ Reboot *bool

+ func NewCreateImage(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *CreateImage

+ func (cmd *CreateImage) BeforeRun(renv env.Running) error

+ func (cmd *CreateImage) ExtractResult(i interface{}) string

+ func (cmd *CreateImage) ParamsSpec() params.Spec

+ func (cmd *CreateImage) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *CreateImage) SetApi(api ec2iface.EC2API)

type CreateInstance

+ func (cmd *CreateInstance) ParamsSpec() params.Spec

type CreateInstanceprofile

+ func (cmd *CreateInstanceprofile) ParamsSpec() params.Spec

type CreateInternetgateway

+ func (cmd *CreateInternetgateway) ParamsSpec() params.Spec

type CreateKeypair

+ func (cmd *CreateKeypair) ParamsSpec() params.Spec

type CreateLaunchconfiguration

+ func (cmd *CreateLaunchconfiguration) ParamsSpec() params.Spec

type CreateListener

+ func (cmd *CreateListener) ParamsSpec() params.Spec

type CreateLoadbalancer

+ func (cmd *CreateLoadbalancer) ParamsSpec() params.Spec

type CreateLoginprofile

+ func (cmd *CreateLoginprofile) ParamsSpec() params.Spec

type CreateMfadevice

+ func (cmd *CreateMfadevice) ParamsSpec() params.Spec

type CreateNatgateway

+ func (cmd *CreateNatgateway) ParamsSpec() params.Spec

type CreateNetworkinterface

+ func (cmd *CreateNetworkinterface) ParamsSpec() params.Spec

type CreatePolicy

+ func (cmd *CreatePolicy) ParamsSpec() params.Spec

type CreateQueue

+ func (cmd *CreateQueue) ParamsSpec() params.Spec

type CreateRecord

+ Values []*string

+ func (cmd *CreateRecord) ParamsSpec() params.Spec

type CreateRepository

+ func (cmd *CreateRepository) ParamsSpec() params.Spec

type CreateRole

+ func (cmd *CreateRole) ParamsSpec() params.Spec

type CreateRoute

+ func (cmd *CreateRoute) ParamsSpec() params.Spec

type CreateRoutetable

+ func (cmd *CreateRoutetable) ParamsSpec() params.Spec

type CreateS3object

+ func (cmd *CreateS3object) ParamsSpec() params.Spec

type CreateScalinggroup

+ func (cmd *CreateScalinggroup) ParamsSpec() params.Spec

type CreateScalingpolicy

+ func (cmd *CreateScalingpolicy) ParamsSpec() params.Spec

type CreateSecuritygroup

+ func (cmd *CreateSecuritygroup) ParamsSpec() params.Spec

type CreateSnapshot

+ func (cmd *CreateSnapshot) ParamsSpec() params.Spec

type CreateStack

+ PolicyBody *string

+ StackFile *string

+ Tags []*string

+ func (cmd *CreateStack) BeforeRun(renv env.Running) error

+ func (cmd *CreateStack) ParamsSpec() params.Spec

type CreateSubnet

+ func (cmd *CreateSubnet) ParamsSpec() params.Spec

type CreateSubscription

+ func (cmd *CreateSubscription) ParamsSpec() params.Spec

type CreateTag

+ func (cmd *CreateTag) ParamsSpec() params.Spec

type CreateTargetgroup

+ func (cmd *CreateTargetgroup) ParamsSpec() params.Spec

type CreateTopic

+ func (cmd *CreateTopic) ParamsSpec() params.Spec

type CreateUser

+ func (cmd *CreateUser) ParamsSpec() params.Spec

type CreateVolume

+ func (cmd *CreateVolume) ParamsSpec() params.Spec

type CreateVpc

+ func (cmd *CreateVpc) ParamsSpec() params.Spec

type CreateZone

+ func (cmd *CreateZone) ParamsSpec() params.Spec

type Definition

+ Params params.Rule

type DeleteAccesskey

+ func (cmd *DeleteAccesskey) ParamsSpec() params.Spec

type DeleteAlarm

+ func (cmd *DeleteAlarm) ParamsSpec() params.Spec

type DeleteAppscalingpolicy

+ func (cmd *DeleteAppscalingpolicy) ParamsSpec() params.Spec

type DeleteAppscalingtarget

+ func (cmd *DeleteAppscalingtarget) ParamsSpec() params.Spec

type DeleteBucket

+ func (cmd *DeleteBucket) ParamsSpec() params.Spec

type DeleteCertificate

+ func (cmd *DeleteCertificate) ParamsSpec() params.Spec

type DeleteContainercluster

+ func (cmd *DeleteContainercluster) ParamsSpec() params.Spec

type DeleteContainertask

+ func (cmd *DeleteContainertask) ParamsSpec() params.Spec

type DeleteDatabase

+ func (cmd *DeleteDatabase) ParamsSpec() params.Spec

type DeleteDbsubnetgroup

+ func (cmd *DeleteDbsubnetgroup) ParamsSpec() params.Spec

type DeleteDistribution

+ func (cmd *DeleteDistribution) ParamsSpec() params.Spec

type DeleteElasticip

+ func (cmd *DeleteElasticip) ParamsSpec() params.Spec

type DeleteFunction

+ func (cmd *DeleteFunction) ParamsSpec() params.Spec

type DeleteGroup

+ func (cmd *DeleteGroup) ParamsSpec() params.Spec

type DeleteImage

+ func (cmd *DeleteImage) ParamsSpec() params.Spec

type DeleteInstance

+ func (cmd *DeleteInstance) ParamsSpec() params.Spec

type DeleteInstanceprofile

+ func (cmd *DeleteInstanceprofile) ParamsSpec() params.Spec

type DeleteInternetgateway

+ func (cmd *DeleteInternetgateway) ParamsSpec() params.Spec

type DeleteKeypair

+ func (cmd *DeleteKeypair) ParamsSpec() params.Spec

type DeleteLaunchconfiguration

+ func (cmd *DeleteLaunchconfiguration) ParamsSpec() params.Spec

type DeleteListener

+ func (cmd *DeleteListener) ParamsSpec() params.Spec

type DeleteLoadbalancer

+ func (cmd *DeleteLoadbalancer) ParamsSpec() params.Spec

type DeleteLoginprofile

+ func (cmd *DeleteLoginprofile) ParamsSpec() params.Spec

type DeleteMfadevice

+ func (cmd *DeleteMfadevice) ParamsSpec() params.Spec

type DeleteNatgateway

+ func (cmd *DeleteNatgateway) ParamsSpec() params.Spec

type DeleteNetworkinterface

+ func (cmd *DeleteNetworkinterface) ParamsSpec() params.Spec

type DeletePolicy

+ func (cmd *DeletePolicy) ParamsSpec() params.Spec

type DeleteQueue

+ func (cmd *DeleteQueue) ParamsSpec() params.Spec

type DeleteRecord

+ Values []*string

+ func (cmd *DeleteRecord) ParamsSpec() params.Spec

type DeleteRepository

+ func (cmd *DeleteRepository) ParamsSpec() params.Spec

type DeleteRole

+ func (cmd *DeleteRole) ParamsSpec() params.Spec

type DeleteRoute

+ func (cmd *DeleteRoute) ParamsSpec() params.Spec

type DeleteRoutetable

+ func (cmd *DeleteRoutetable) ParamsSpec() params.Spec

type DeleteS3object

+ func (cmd *DeleteS3object) ParamsSpec() params.Spec

type DeleteScalinggroup

+ func (cmd *DeleteScalinggroup) ParamsSpec() params.Spec

type DeleteScalingpolicy

+ func (cmd *DeleteScalingpolicy) ParamsSpec() params.Spec

type DeleteSecuritygroup

+ func (cmd *DeleteSecuritygroup) ParamsSpec() params.Spec

type DeleteSnapshot

+ func (cmd *DeleteSnapshot) ParamsSpec() params.Spec

type DeleteStack

+ func (cmd *DeleteStack) ParamsSpec() params.Spec

type DeleteSubnet

+ func (cmd *DeleteSubnet) ParamsSpec() params.Spec

type DeleteSubscription

+ func (cmd *DeleteSubscription) ParamsSpec() params.Spec

type DeleteTag

+ func (cmd *DeleteTag) ParamsSpec() params.Spec

type DeleteTargetgroup

+ func (cmd *DeleteTargetgroup) ParamsSpec() params.Spec

type DeleteTopic

+ func (cmd *DeleteTopic) ParamsSpec() params.Spec

type DeleteUser

+ func (cmd *DeleteUser) ParamsSpec() params.Spec

type DeleteVolume

+ func (cmd *DeleteVolume) ParamsSpec() params.Spec

type DeleteVpc

+ func (cmd *DeleteVpc) ParamsSpec() params.Spec

type DeleteZone

+ func (cmd *DeleteZone) ParamsSpec() params.Spec

type DetachAlarm

+ func (cmd *DetachAlarm) ParamsSpec() params.Spec

type DetachContainertask

+ func (cmd *DetachContainertask) ParamsSpec() params.Spec

type DetachElasticip

+ func (cmd *DetachElasticip) ParamsSpec() params.Spec

type DetachInstance

+ func (cmd *DetachInstance) ParamsSpec() params.Spec

type DetachInstanceprofile

+ func (cmd *DetachInstanceprofile) ParamsSpec() params.Spec

type DetachInternetgateway

+ func (cmd *DetachInternetgateway) ParamsSpec() params.Spec

type DetachMfadevice

+ func (cmd *DetachMfadevice) ParamsSpec() params.Spec

type DetachNetworkinterface

+ func (cmd *DetachNetworkinterface) ParamsSpec() params.Spec

type DetachPolicy

+ func (cmd *DetachPolicy) ParamsSpec() params.Spec

type DetachRole

+ func (cmd *DetachRole) ParamsSpec() params.Spec

type DetachRoutetable

+ func (cmd *DetachRoutetable) ParamsSpec() params.Spec

type DetachSecuritygroup

+ func (cmd *DetachSecuritygroup) ParamsSpec() params.Spec

type DetachUser

+ func (cmd *DetachUser) ParamsSpec() params.Spec

type DetachVolume

+ func (cmd *DetachVolume) ParamsSpec() params.Spec

type ImportImage

+ func (cmd *ImportImage) ParamsSpec() params.Spec

+ type RestartDatabase struct

+ Id *string

+ WithFailover *bool

+ func NewRestartDatabase(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *RestartDatabase

+ func (cmd *RestartDatabase) ParamsSpec() params.Spec

+ func (cmd *RestartDatabase) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *RestartDatabase) SetApi(api rdsiface.RDSAPI)

+ type RestartInstance struct

+ Id []*string

+ func NewRestartInstance(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *RestartInstance

+ func (cmd *RestartInstance) ParamsSpec() params.Spec

+ func (cmd *RestartInstance) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *RestartInstance) SetApi(api ec2iface.EC2API)

type StartAlarm

+ func (cmd *StartAlarm) ParamsSpec() params.Spec

type StartContainertask

+ func (cmd *StartContainertask) ParamsSpec() params.Spec

+ type StartDatabase struct

+ Id *string

+ func NewStartDatabase(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *StartDatabase

+ func (cmd *StartDatabase) ParamsSpec() params.Spec

+ func (cmd *StartDatabase) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *StartDatabase) SetApi(api rdsiface.RDSAPI)

type StartInstance

+ func (cmd *StartInstance) ParamsSpec() params.Spec

type StopAlarm

+ func (cmd *StopAlarm) ParamsSpec() params.Spec

type StopContainertask

+ func (cmd *StopContainertask) ParamsSpec() params.Spec

+ type StopDatabase struct

+ Id *string

+ func NewStopDatabase(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *StopDatabase

+ func (cmd *StopDatabase) ParamsSpec() params.Spec

+ func (cmd *StopDatabase) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *StopDatabase) SetApi(api rdsiface.RDSAPI)

type StopInstance

+ func (cmd *StopInstance) ParamsSpec() params.Spec

type UpdateBucket

+ func (cmd *UpdateBucket) ParamsSpec() params.Spec

type UpdateContainertask

+ func (cmd *UpdateContainertask) ParamsSpec() params.Spec

type UpdateDistribution

+ func (cmd *UpdateDistribution) ParamsSpec() params.Spec

+ type UpdateImage struct

+ Accounts []*string

+ Description *string

+ Groups []*string

+ Id *string

+ Operation *string

+ ProductCodes []*string

+ func NewUpdateImage(sess *session.Session, g cloud.GraphAPI, l ...*logger.Logger) *UpdateImage

+ func (cmd *UpdateImage) ManualRun(renv env.Running) (interface{}, error)

+ func (cmd *UpdateImage) ParamsSpec() params.Spec

+ func (cmd *UpdateImage) Run(renv env.Running, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateImage) SetApi(api ec2iface.EC2API)

type UpdateInstance

+ func (cmd *UpdateInstance) ParamsSpec() params.Spec

type UpdateLoginprofile

+ func (cmd *UpdateLoginprofile) ParamsSpec() params.Spec

type UpdatePolicy

+ func (cmd *UpdatePolicy) ParamsSpec() params.Spec

type UpdateRecord

+ Values []*string

+ func (cmd *UpdateRecord) ParamsSpec() params.Spec

type UpdateS3object

+ func (cmd *UpdateS3object) ParamsSpec() params.Spec

type UpdateScalinggroup

+ func (cmd *UpdateScalinggroup) ParamsSpec() params.Spec

type UpdateSecuritygroup

+ func (cmd *UpdateSecuritygroup) ParamsSpec() params.Spec

type UpdateStack

+ PolicyBody *string

+ StackFile *string

+ Tags []*string

+ func (cmd *UpdateStack) BeforeRun(renv env.Running) error

+ func (cmd *UpdateStack) ParamsSpec() params.Spec

type UpdateSubnet

+ func (cmd *UpdateSubnet) ParamsSpec() params.Spec

type UpdateTargetgroup

+ func (cmd *UpdateTargetgroup) ParamsSpec() params.Spec

v0.1.8

Nov 29, 2017

Changes in this version

type CreateDatabase

+ CopyTagsToSnapshot *string

+ ReadReplicaIdentifier *string

+ ReadReplicaSourceDB *string

+ func (cmd *CreateDatabase) ManualRun(ctx map[string]interface{}) (output interface{}, err error)

+ func (cmd *CreateDatabase) Validate_Password() (err error)

+ func (cmd *CreateDatabase) Validate_ReadReplicaIdentifier() error

type UpdateSecuritygroup

+ func (cmd *UpdateSecuritygroup) Validate_Protocol() error

v0.1.7

Nov 24, 2017

Changes in this version

+ const ImageQuerySpec

+ var AmazonLinux = Platform

+ var Canonical = Platform

+ var Debian = Platform

+ var DefaultImageResolverCache = new(ImageResolverCache)

+ var MockAWSSessionFactory = &AWSFactory

+ var Platforms = map[string]Platform

+ var RedHat = Platform

+ var SupportedAMIOwners []string

+ var SuseLinux = Platform

+ var Windows = Platform

type AttachPolicy

+ Access *string

+ Service *string

+ type AwsImage struct

+ Architecture string

+ Created time.Time

+ Hypervisor string

+ Id string

+ Location string

+ Name string

+ Owner string

+ Store string

+ Type string

+ VirtualizationType string

type CreateAccesskey

+ Save *bool

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

type CreateInstance

+ DistroQuery *string

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

type CreateLaunchconfiguration

+ DistroQuery *string

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

type CreateSubnet

+ Public *bool

+ type Distro struct

+ Arch string

+ Name string

+ Store string

+ Variant string

+ Virt string

+ type ImageQuery struct

+ Distro Distro

+ Platform Platform

+ func ParseImageQuery(s string) (ImageQuery, error)

+ func (q ImageQuery) String() string

+ type ImageResolver func(*ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error)

+ func EC2ImageResolver() ImageResolver

+ func (resolv ImageResolver) Resolve(q ImageQuery) ([]*AwsImage, bool, error)

+ type ImageResolverCache struct

+ func (r *ImageResolverCache) Get(key string) ([]*AwsImage, bool)

+ func (r *ImageResolverCache) Store(key string, images []*AwsImage)

+ type Platform struct

+ DistroName string

+ Id string

+ LatestVariant string

+ MatchFunc func(s string, d Distro) bool

+ Name string

type UpdateDistribution

+ Certificate *string

+ Comment *string

+ DefaultFile *string

+ DomainAliases []*string

+ ForwardCookies *string

+ ForwardQueries *bool

+ HttpsBehaviour *string

+ MinTtl *int64

+ OriginDomain *string

+ OriginPath *string

+ PriceClass *string

v0.1.6

Nov 16, 2017

Changes in this version

+ var APIPerTemplateDefName = map[string]string

+ var AWSCredFilepath = filepath.Join(awsHomeDir(), "credentials")

+ var AWSTemplatesDefinitions = map[string]Definition

+ var CallerReferenceFunc = func() string

+ var DriverSupportedActions = map[string][]string

+ var NoSessionFactory = &AWSFactory

+ var ProgressBarFactory func(*os.File) (*ProgressReadSeeker, error)

+ func Bool(v bool) *bool

+ func BoolValue(v *bool) bool

+ func Int64(v int64) *int64

+ func Int64AsIntValue(v *int64) int

+ func NewCredsPrompter(profile string) *credentialsPrompter

+ func NewEnumValidator(expected ...string) *enumValidator

+ func String(v string) *string

+ func StringValue(v *string) string

+ type AWSFactory struct

+ Log *logger.Logger

+ Sess *session.Session

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

+ type AfterRunner interface

+ AfterRun func(ctx map[string]interface{}, output interface{}) error

+ type AttachAlarm struct

+ ActionArn *string

+ Name *string

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

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

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

+ func (cmd *AttachAlarm) ParamsHelp() string

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

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

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

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

+ type AttachContainertask struct

+ Commands []*string

+ ContainerName *string

+ Env []*string

+ Image *string

+ MemoryHardLimit *int64

+ Name *string

+ Ports []*string

+ Privileged *bool

+ Workdir *string

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

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

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

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

+ func (cmd *AttachContainertask) ParamsHelp() string

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

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

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

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

+ type AttachElasticip struct

+ AllowReassociation *bool

+ Id *string

+ Instance *string

+ Networkinterface *string

+ Privateip *string

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

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

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

+ func (cmd *AttachElasticip) ParamsHelp() string

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

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

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

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

+ type AttachInstance struct

+ Id *string

+ Port *int64

+ Targetgroup *string

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

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

+ func (cmd *AttachInstance) ParamsHelp() string

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

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

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

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

+ type AttachInstanceprofile struct

+ Instance *string

+ Name *string

+ Replace *bool

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

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

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

+ func (cmd *AttachInstanceprofile) ParamsHelp() string

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

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

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

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

+ type AttachInternetgateway struct

+ Id *string

+ Vpc *string

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

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

+ func (cmd *AttachInternetgateway) ParamsHelp() string

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

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

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

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

+ type AttachMfadevice struct

+ Id *string

+ MfaCode1 *string

+ MfaCode2 *string

+ NoPrompt *bool

+ User *string

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

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

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

+ func (cmd *AttachMfadevice) ParamsHelp() string

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

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

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

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

+ type AttachNetworkinterface struct

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

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

+ func (cmd *AttachNetworkinterface) ParamsHelp() string

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

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

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

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

+ DeviceIndex *int64

+ Id *string

+ Instance *string

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

+ type AttachPolicy struct

+ Arn *string

+ Group *string

+ Role *string

+ User *string

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

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

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

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

+ func (cmd *AttachPolicy) ParamsHelp() string

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

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

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

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

+ type AttachRole struct

+ Instanceprofile *string

+ Name *string

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

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

+ func (cmd *AttachRole) ParamsHelp() string

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

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

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

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

+ type AttachRoutetable struct

+ Id *string

+ Subnet *string

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

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

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

+ func (cmd *AttachRoutetable) ParamsHelp() string

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

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

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

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

+ type AttachSecuritygroup struct

+ Id *string

+ Instance *string

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

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

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

+ func (cmd *AttachSecuritygroup) ParamsHelp() string

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

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

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

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

+ type AttachUser struct

+ Group *string

+ Name *string

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

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

+ func (cmd *AttachUser) ParamsHelp() string

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

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

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

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

+ type AttachVolume struct

+ Device *string

+ Id *string

+ Instance *string

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

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

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

+ func (cmd *AttachVolume) ParamsHelp() string

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

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

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

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

+ type AuthenticateRegistry struct

+ Accounts []*string

+ DisableDockerCmd *bool

+ NoConfirm *bool

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

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

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

+ func (cmd *AuthenticateRegistry) ParamsHelp() string

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

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

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

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

+ type BeforeRunner interface

+ BeforeRun func(ctx map[string]interface{}) error

+ type CheckCertificate struct

+ Arn *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckCertificate) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckCertificate) Validate_State() error

+ type CheckDatabase struct

+ Id *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckDatabase) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckDatabase) Validate_State() error

+ type CheckDistribution struct

+ Id *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckDistribution) ParamsHelp() string

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

+ func (cmd *CheckDistribution) SetApi(api cloudfrontiface.CloudFrontAPI)

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

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

+ func (cmd *CheckDistribution) Validate_State() error

+ type CheckInstance struct

+ Id *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckInstance) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckInstance) Validate_State() error

+ type CheckLoadbalancer struct

+ Id *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckLoadbalancer) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckLoadbalancer) Validate_State() error

+ type CheckNatgateway struct

+ Id *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckNatgateway) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckNatgateway) Validate_State() error

+ type CheckNetworkinterface struct

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

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

+ func (cmd *CheckNetworkinterface) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckNetworkinterface) Validate_State() error

+ Id *string

+ State *string

+ Timeout *int64

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

+ type CheckScalinggroup struct

+ Count *int64

+ Name *string

+ Timeout *int64

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

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

+ func (cmd *CheckScalinggroup) ParamsHelp() string

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

+ func (cmd *CheckScalinggroup) SetApi(api autoscalingiface.AutoScalingAPI)

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

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

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

+ type CheckSecuritygroup struct

+ Id *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckSecuritygroup) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckSecuritygroup) Validate_State() error

+ type CheckVolume struct

+ Id *string

+ State *string

+ Timeout *int64

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

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

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

+ func (cmd *CheckVolume) ParamsHelp() string

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

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

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

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

+ func (cmd *CheckVolume) Validate_State() error

+ type CopyImage struct

+ Description *string

+ Encrypted *bool

+ Name *string

+ SourceId *string

+ SourceRegion *string

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

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

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

+ func (cmd *CopyImage) ParamsHelp() string

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

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

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

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

+ type CopySnapshot struct

+ Description *string

+ Encrypted *bool

+ SourceId *string

+ SourceRegion *string

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

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

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

+ func (cmd *CopySnapshot) ParamsHelp() string

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

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

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

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

+ type CreateAccesskey struct

+ NoPrompt *bool

+ User *string

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

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

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

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

+ func (cmd *CreateAccesskey) ParamsHelp() string

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

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

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

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

+ type CreateAlarm struct

+ AlarmActions []*string

+ Description *string

+ Dimensions []*string

+ Enabled *bool

+ EvaluationPeriods *int64

+ InsufficientdataActions []*string

+ Metric *string

+ Name *string

+ Namespace *string

+ OkActions []*string

+ Operator *string

+ Period *int64

+ StatisticFunction *string

+ Threshold *float64

+ Unit *string

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

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

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

+ func (cmd *CreateAlarm) ParamsHelp() string

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

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

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

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

+ func (cmd *CreateAlarm) Validate_Operator() error

+ type CreateAppscalingpolicy struct

+ Dimension *string

+ Name *string

+ Resource *string

+ ServiceNamespace *string

+ StepscalingAdjustmentType *string

+ StepscalingAdjustments []*string

+ StepscalingAggregationType *string

+ StepscalingCooldown *int64

+ StepscalingMinAdjustmentMagnitude *int64

+ Type *string

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

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

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

+ func (cmd *CreateAppscalingpolicy) ParamsHelp() string

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

+ func (cmd *CreateAppscalingpolicy) SetApi(api applicationautoscalingiface.ApplicationAutoScalingAPI)

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

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

+ type CreateAppscalingtarget struct

+ Dimension *string

+ MaxCapacity *int64

+ MinCapacity *int64

+ Resource *string

+ Role *string

+ ServiceNamespace *string

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

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

+ func (cmd *CreateAppscalingtarget) ParamsHelp() string

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

+ func (cmd *CreateAppscalingtarget) SetApi(api applicationautoscalingiface.ApplicationAutoScalingAPI)

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

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

+ type CreateBucket struct

+ Acl *string

+ Name *string

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

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

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

+ func (cmd *CreateBucket) ParamsHelp() string

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

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

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

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

+ type CreateCertificate struct

+ Domains []*string

+ ValidationDomains []*string

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

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

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

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

+ func (cmd *CreateCertificate) ParamsHelp() string

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

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

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

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

+ type CreateContainercluster struct

+ Name *string

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

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

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

+ func (cmd *CreateContainercluster) ParamsHelp() string

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

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

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

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

+ type CreateDatabase struct

+ Autoupgrade *bool

+ Availabilityzone *string

+ Backupretention *int64

+ Backupwindow *string

+ Cluster *string

+ Dbname *string

+ Dbsecuritygroups []*string

+ Domain *string

+ Encrypted *bool

+ Engine *string

+ Iamrole *string

+ Id *string

+ Iops *int64

+ License *string

+ Maintenancewindow *string

+ Multiaz *bool

+ Optiongroup *string

+ Parametergroup *string

+ Password *string

+ Port *int64

+ Public *bool

+ Size *int64

+ Storagetype *string

+ Subnetgroup *string

+ Timezone *string

+ Type *string

+ Username *string

+ Version *string

+ Vpcsecuritygroups []*string

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

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

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

+ func (cmd *CreateDatabase) ParamsHelp() string

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

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

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

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

+ type CreateDbsubnetgroup struct

+ Description *string

+ Name *string

+ Subnets []*string

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

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

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

+ func (cmd *CreateDbsubnetgroup) ParamsHelp() string

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

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

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

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

+ type CreateDistribution struct

+ Certificate *string

+ Comment *string

+ DefaultFile *string

+ DomainAliases []*string

+ Enable *bool

+ ForwardCookies *string

+ ForwardQueries *bool

+ HttpsBehaviour *string

+ MinTtl *int64

+ OriginDomain *string

+ OriginPath *string

+ PriceClass *string

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

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

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

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

+ func (cmd *CreateDistribution) ParamsHelp() string

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

+ func (cmd *CreateDistribution) SetApi(api cloudfrontiface.CloudFrontAPI)

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

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

+ type CreateElasticip struct

+ Domain *string

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

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

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

+ func (cmd *CreateElasticip) ParamsHelp() string

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

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

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

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

+ type CreateFunction struct

+ Bucket *string

+ Description *string

+ Handler *string

+ Memory *int64

+ Name *string

+ Object *string

+ Objectversion *string

+ Publish *bool

+ Role *string

+ Runtime *string

+ Timeout *int64

+ Zipfile *string

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

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

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

+ func (cmd *CreateFunction) ParamsHelp() string

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

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

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

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

+ type CreateGroup struct

+ Name *string

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

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

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

+ func (cmd *CreateGroup) ParamsHelp() string

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

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

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

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

+ type CreateInstance struct

+ Count *int64

+ Image *string

+ Keypair *string

+ Lock *bool

+ Name *string

+ PrivateIP *string

+ Role *string

+ SecurityGroups []*string

+ Subnet *string

+ Type *string

+ UserData *string

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

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

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

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

+ func (cmd *CreateInstance) ParamsHelp() string

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

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

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

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

+ type CreateInstanceprofile struct

+ Name *string

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

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

+ func (cmd *CreateInstanceprofile) ParamsHelp() string

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

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

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

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

+ type CreateInternetgateway struct

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

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

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

+ func (cmd *CreateInternetgateway) ParamsHelp() string

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

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

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

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

+ type CreateKeypair struct

+ Encrypted *bool

+ Name *string

+ PublicKeyMaterial []byte

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

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

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

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

+ func (cmd *CreateKeypair) ParamsHelp() string

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

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

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

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

+ func (cmd *CreateKeypair) Validate_Name() error

+ type CreateLaunchconfiguration struct

+ Image *string

+ Keypair *string

+ Name *string

+ Public *bool

+ Role *string

+ Securitygroups []*string

+ Spotprice *string

+ Type *string

+ Userdata *string

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

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

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

+ func (cmd *CreateLaunchconfiguration) ParamsHelp() string

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

+ func (cmd *CreateLaunchconfiguration) SetApi(api autoscalingiface.AutoScalingAPI)

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

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

+ type CreateListener struct

+ Actiontype *string

+ Certificate *string

+ Loadbalancer *string

+ Port *int64

+ Protocol *string

+ Sslpolicy *string

+ Targetgroup *string

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

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

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

+ func (cmd *CreateListener) ParamsHelp() string

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

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

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

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

+ type CreateLoadbalancer struct

+ Iptype *string

+ Name *string

+ Scheme *string

+ Securitygroups []*string

+ SubnetMappings []*string

+ Subnets []*string

+ Type *string

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

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

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

+ func (cmd *CreateLoadbalancer) ParamsHelp() string

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

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

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

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

+ type CreateLoginprofile struct

+ Password *string

+ PasswordReset *bool

+ Username *string

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

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

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

+ func (cmd *CreateLoginprofile) ParamsHelp() string

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

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

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

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

+ type CreateMfadevice struct

+ Name *string

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

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

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

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

+ func (cmd *CreateMfadevice) ParamsHelp() string

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

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

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

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

+ type CreateNatgateway struct

+ ElasticipId *string

+ Subnet *string

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

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

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

+ func (cmd *CreateNatgateway) ParamsHelp() string

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

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

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

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

+ type CreateNetworkinterface struct

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

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

+ func (cmd *CreateNetworkinterface) ParamsHelp() string

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

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

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

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

+ Description *string

+ Privateip *string

+ Securitygroups []*string

+ Subnet *string

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

+ type CreatePolicy struct

+ Action []*string

+ Conditions []*string

+ Description *string

+ Document *string

+ Effect *string

+ Name *string

+ Resource []*string

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

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

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

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

+ func (cmd *CreatePolicy) ParamsHelp() string

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

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

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

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

+ type CreateQueue struct

+ Delay *string

+ MaxMsgSize *string

+ MsgWait *string

+ Name *string

+ Policy *string

+ RedrivePolicy *string

+ RetentionPeriod *string

+ VisibilityTimeout *string

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

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

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

+ func (cmd *CreateQueue) ParamsHelp() string

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

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

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

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

+ type CreateRecord struct

+ Comment *string

+ Name *string

+ Ttl *int64

+ Type *string

+ Value *string

+ Zone *string

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

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

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

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

+ func (cmd *CreateRecord) ParamsHelp() string

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

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

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

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

+ type CreateRepository struct

+ Name *string

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

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

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

+ func (cmd *CreateRepository) ParamsHelp() string

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

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

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

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

+ type CreateRole struct

+ Conditions []*string

+ Name *string

+ PrincipalAccount *string

+ PrincipalService *string

+ PrincipalUser *string

+ SleepAfter *int64

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

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

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

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

+ func (cmd *CreateRole) ParamsHelp() string

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

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

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

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

+ type CreateRoute struct

+ CIDR *string

+ Gateway *string

+ Table *string

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

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

+ func (cmd *CreateRoute) ParamsHelp() string

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

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

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

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

+ func (cmd *CreateRoute) Validate_CIDR() error

+ type CreateRoutetable struct

+ Vpc *string

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

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

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

+ func (cmd *CreateRoutetable) ParamsHelp() string

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

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

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

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

+ type CreateS3object struct

+ Acl *string

+ Bucket *string

+ File *string

+ Name *string

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

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

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

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

+ func (cmd *CreateS3object) ParamsHelp() string

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

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

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

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

+ func (cmd *CreateS3object) Validate_File() error

+ type CreateScalinggroup struct

+ Cooldown *int64

+ DesiredCapacity *int64

+ HealthcheckGracePeriod *int64

+ HealthcheckType *string

+ Launchconfiguration *string

+ MaxSize *int64

+ MinSize *int64

+ Name *string

+ NewInstancesProtected *bool

+ Subnets []*string

+ Targetgroups []*string

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

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

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

+ func (cmd *CreateScalinggroup) ParamsHelp() string

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

+ func (cmd *CreateScalinggroup) SetApi(api autoscalingiface.AutoScalingAPI)

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

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

+ type CreateScalingpolicy struct

+ AdjustmentMagnitude *int64

+ AdjustmentScaling *int64

+ AdjustmentType *string

+ Cooldown *int64

+ Name *string

+ Scalinggroup *string

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

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

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

+ func (cmd *CreateScalingpolicy) ParamsHelp() string

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

+ func (cmd *CreateScalingpolicy) SetApi(api autoscalingiface.AutoScalingAPI)

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

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

+ type CreateSecuritygroup struct

+ Description *string

+ Name *string

+ Vpc *string

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

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

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

+ func (cmd *CreateSecuritygroup) ParamsHelp() string

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

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

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

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

+ type CreateSnapshot struct

+ Description *string

+ Volume *string

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

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

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

+ func (cmd *CreateSnapshot) ParamsHelp() string

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

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

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

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

+ type CreateStack struct

+ Capabilities []*string

+ DisableRollback *bool

+ Name *string

+ Notifications []*string

+ OnFailure *string

+ Parameters []*string

+ PolicyFile *string

+ ResourceTypes []*string

+ Role *string

+ TemplateFile *string

+ Timeout *int64

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

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

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

+ func (cmd *CreateStack) ParamsHelp() string

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

+ func (cmd *CreateStack) SetApi(api cloudformationiface.CloudFormationAPI)

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

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

+ func (cmd *CreateStack) Validate_TemplateFile() error

+ type CreateSubnet struct

+ AvailabilityZone *string

+ CIDR *string

+ Name *string

+ VPC *string

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

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

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

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

+ func (cmd *CreateSubnet) ParamsHelp() string

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

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

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

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

+ func (cmd *CreateSubnet) Validate_CIDR() error

+ type CreateSubscription struct

+ Endpoint *string

+ Protocol *string

+ Topic *string

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

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

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

+ func (cmd *CreateSubscription) ParamsHelp() string

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

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

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

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

+ type CreateTag struct

+ Key *string

+ Resource *string

+ Value *string

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

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

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

+ func (cmd *CreateTag) ParamsHelp() string

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

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

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

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

+ type CreateTargetgroup struct

+ Healthcheckinterval *int64

+ Healthcheckpath *string

+ Healthcheckport *string

+ Healthcheckprotocol *string

+ Healthchecktimeout *int64

+ Healthythreshold *int64

+ Matcher *string

+ Name *string

+ Port *int64

+ Protocol *string

+ Unhealthythreshold *int64

+ Vpc *string

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

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

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

+ func (cmd *CreateTargetgroup) ParamsHelp() string

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

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

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

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

+ type CreateTopic struct

+ Name *string

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

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

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

+ func (cmd *CreateTopic) ParamsHelp() string

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

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

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

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

+ type CreateUser struct

+ Name *string

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

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

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

+ func (cmd *CreateUser) ParamsHelp() string

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

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

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

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

+ type CreateVolume struct

+ Availabilityzone *string

+ Size *int64

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

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

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

+ func (cmd *CreateVolume) ParamsHelp() string

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

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

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

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

+ type CreateVpc struct

+ CIDR *string

+ Name *string

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

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

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

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

+ func (cmd *CreateVpc) ParamsHelp() string

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

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

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

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

+ func (cmd *CreateVpc) Validate_CIDR() error

+ type CreateZone struct

+ Callerreference *string

+ Comment *string

+ Delegationsetid *string

+ Isprivate *bool

+ Name *string

+ Vpcid *string

+ Vpcregion *string

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

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

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

+ func (cmd *CreateZone) ParamsHelp() string

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

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

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

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

+ type Definition struct

+ Action string

+ Api string

+ Entity string

+ ExtraParams []string

+ RequiredParams []string

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

+ type DeleteAccesskey struct

+ Id *string

+ User *string

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

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

+ func (cmd *DeleteAccesskey) ParamsHelp() string

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

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

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

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

+ type DeleteAlarm struct

+ Name []*string

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

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

+ func (cmd *DeleteAlarm) ParamsHelp() string

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

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

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

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

+ type DeleteAppscalingpolicy struct

+ Dimension *string

+ Name *string

+ Resource *string

+ ServiceNamespace *string

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

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

+ func (cmd *DeleteAppscalingpolicy) ParamsHelp() string

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

+ func (cmd *DeleteAppscalingpolicy) SetApi(api applicationautoscalingiface.ApplicationAutoScalingAPI)

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

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

+ type DeleteAppscalingtarget struct

+ Dimension *string

+ Resource *string

+ ServiceNamespace *string

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

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

+ func (cmd *DeleteAppscalingtarget) ParamsHelp() string

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

+ func (cmd *DeleteAppscalingtarget) SetApi(api applicationautoscalingiface.ApplicationAutoScalingAPI)

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

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

+ type DeleteBucket struct

+ Name *string

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

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

+ func (cmd *DeleteBucket) ParamsHelp() string

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

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

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

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

+ type DeleteCertificate struct

+ Arn *string

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

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

+ func (cmd *DeleteCertificate) ParamsHelp() string

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

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

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

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

+ type DeleteContainercluster struct

+ Id *string

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

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

+ func (cmd *DeleteContainercluster) ParamsHelp() string

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

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

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

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

+ type DeleteContainertask struct

+ AllVersions *bool

+ Name *string

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

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

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

+ func (cmd *DeleteContainertask) ParamsHelp() string

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

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

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

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

+ type DeleteDatabase struct

+ Id *string

+ SkipSnapshot *bool

+ Snapshot *string

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

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

+ func (cmd *DeleteDatabase) ParamsHelp() string

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

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

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

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

+ type DeleteDbsubnetgroup struct

+ Name *string

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

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

+ func (cmd *DeleteDbsubnetgroup) ParamsHelp() string

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

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

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

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

+ type DeleteDistribution struct

+ Id *string

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

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

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

+ func (cmd *DeleteDistribution) ParamsHelp() string

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

+ func (cmd *DeleteDistribution) SetApi(api cloudfrontiface.CloudFrontAPI)

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

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

+ type DeleteElasticip struct

+ Id *string

+ Ip *string

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

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

+ func (cmd *DeleteElasticip) ParamsHelp() string

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

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

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

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

+ type DeleteFunction struct

+ Id *string

+ Version *string

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

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

+ func (cmd *DeleteFunction) ParamsHelp() string

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

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

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

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

+ type DeleteGroup struct

+ Name *string

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

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

+ func (cmd *DeleteGroup) ParamsHelp() string

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

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

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

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

+ type DeleteImage struct

+ DeleteSnapshots *bool

+ Id *string

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

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

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

+ func (cmd *DeleteImage) ParamsHelp() string

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

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

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

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

+ type DeleteInstance struct

+ IDs []*string

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

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

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

+ func (cmd *DeleteInstance) ParamsHelp() string

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

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

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

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

+ type DeleteInstanceprofile struct

+ Name *string

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

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

+ func (cmd *DeleteInstanceprofile) ParamsHelp() string

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

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

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

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

+ type DeleteInternetgateway struct

+ Id *string

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

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

+ func (cmd *DeleteInternetgateway) ParamsHelp() string

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

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

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

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

+ type DeleteKeypair struct

+ Name *string

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

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

+ func (cmd *DeleteKeypair) ParamsHelp() string

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

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

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

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

+ type DeleteLaunchconfiguration struct

+ Name *string

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

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

+ func (cmd *DeleteLaunchconfiguration) ParamsHelp() string

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

+ func (cmd *DeleteLaunchconfiguration) SetApi(api autoscalingiface.AutoScalingAPI)

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

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

+ type DeleteListener struct

+ Id *string

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

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

+ func (cmd *DeleteListener) ParamsHelp() string

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

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

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

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

+ type DeleteLoadbalancer struct

+ Id *string

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

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

+ func (cmd *DeleteLoadbalancer) ParamsHelp() string

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

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

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

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

+ type DeleteLoginprofile struct

+ Username *string

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

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

+ func (cmd *DeleteLoginprofile) ParamsHelp() string

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

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

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

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

+ type DeleteMfadevice struct

+ Id *string

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

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

+ func (cmd *DeleteMfadevice) ParamsHelp() string

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

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

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

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

+ type DeleteNatgateway struct

+ Id *string

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

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

+ func (cmd *DeleteNatgateway) ParamsHelp() string

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

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

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

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

+ type DeleteNetworkinterface struct

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

+ func (cmd *DeleteNetworkinterface) ParamsHelp() string

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

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

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

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

+ Id *string

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

+ type DeletePolicy struct

+ AllVersions *bool

+ Arn *string

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

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

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

+ func (cmd *DeletePolicy) ParamsHelp() string

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

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

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

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

+ type DeleteQueue struct

+ Url *string

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

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

+ func (cmd *DeleteQueue) ParamsHelp() string

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

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

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

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

+ type DeleteRecord struct

+ Name *string

+ Ttl *int64

+ Type *string

+ Value *string

+ Zone *string

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

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

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

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

+ func (cmd *DeleteRecord) ParamsHelp() string

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

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

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

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

+ type DeleteRepository struct

+ Account *string

+ Force *bool

+ Name *string

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

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

+ func (cmd *DeleteRepository) ParamsHelp() string

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

+ func (cmd *DeleteRepository) SetApi(api ecriface.ECRAPI)

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

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

+ type DeleteRole struct

+ Name *string

+ func NewDeleteRole(sess *session.Session, l ...*logger.Logger) *DeleteRole

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

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

+ func (cmd *DeleteRole) ParamsHelp() string

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

+ func (cmd *DeleteRole) SetApi(api iamiface.IAMAPI)

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

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

+ type DeleteRoute struct

+ CIDR *string

+ Table *string

+ func NewDeleteRoute(sess *session.Session, l ...*logger.Logger) *DeleteRoute

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

+ func (cmd *DeleteRoute) ParamsHelp() string

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

+ func (cmd *DeleteRoute) SetApi(api ec2iface.EC2API)

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

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

+ func (cmd *DeleteRoute) Validate_CIDR() error

+ type DeleteRoutetable struct

+ Id *string

+ func NewDeleteRoutetable(sess *session.Session, l ...*logger.Logger) *DeleteRoutetable

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

+ func (cmd *DeleteRoutetable) ParamsHelp() string

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

+ func (cmd *DeleteRoutetable) SetApi(api ec2iface.EC2API)

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

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

+ type DeleteS3object struct

+ Bucket *string

+ Name *string

+ func NewDeleteS3object(sess *session.Session, l ...*logger.Logger) *DeleteS3object

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

+ func (cmd *DeleteS3object) ParamsHelp() string

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

+ func (cmd *DeleteS3object) SetApi(api s3iface.S3API)

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

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

+ type DeleteScalinggroup struct

+ Force *bool

+ Name *string

+ func NewDeleteScalinggroup(sess *session.Session, l ...*logger.Logger) *DeleteScalinggroup

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

+ func (cmd *DeleteScalinggroup) ParamsHelp() string

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

+ func (cmd *DeleteScalinggroup) SetApi(api autoscalingiface.AutoScalingAPI)

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

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

+ type DeleteScalingpolicy struct

+ Id *string

+ func NewDeleteScalingpolicy(sess *session.Session, l ...*logger.Logger) *DeleteScalingpolicy

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

+ func (cmd *DeleteScalingpolicy) ParamsHelp() string

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

+ func (cmd *DeleteScalingpolicy) SetApi(api autoscalingiface.AutoScalingAPI)

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

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

+ type DeleteSecuritygroup struct

+ Id *string

+ func NewDeleteSecuritygroup(sess *session.Session, l ...*logger.Logger) *DeleteSecuritygroup

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

+ func (cmd *DeleteSecuritygroup) ParamsHelp() string

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

+ func (cmd *DeleteSecuritygroup) SetApi(api ec2iface.EC2API)

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

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

+ type DeleteSnapshot struct

+ Id *string

+ func NewDeleteSnapshot(sess *session.Session, l ...*logger.Logger) *DeleteSnapshot

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

+ func (cmd *DeleteSnapshot) ParamsHelp() string

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

+ func (cmd *DeleteSnapshot) SetApi(api ec2iface.EC2API)

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

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

+ type DeleteStack struct

+ Name *string

+ RetainResources []*string

+ func NewDeleteStack(sess *session.Session, l ...*logger.Logger) *DeleteStack

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

+ func (cmd *DeleteStack) ParamsHelp() string

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

+ func (cmd *DeleteStack) SetApi(api cloudformationiface.CloudFormationAPI)

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

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

+ type DeleteSubnet struct

+ Id *string

+ func NewDeleteSubnet(sess *session.Session, l ...*logger.Logger) *DeleteSubnet

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

+ func (cmd *DeleteSubnet) ParamsHelp() string

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

+ func (cmd *DeleteSubnet) SetApi(api ec2iface.EC2API)

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

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

+ type DeleteSubscription struct

+ Id *string

+ func NewDeleteSubscription(sess *session.Session, l ...*logger.Logger) *DeleteSubscription

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

+ func (cmd *DeleteSubscription) ParamsHelp() string

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

+ func (cmd *DeleteSubscription) SetApi(api snsiface.SNSAPI)

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

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

+ type DeleteTag struct

+ Key *string

+ Resource *string

+ Value *string

+ func NewDeleteTag(sess *session.Session, l ...*logger.Logger) *DeleteTag

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

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

+ func (cmd *DeleteTag) ParamsHelp() string

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

+ func (cmd *DeleteTag) SetApi(api ec2iface.EC2API)

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

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

+ type DeleteTargetgroup struct

+ Id *string

+ func NewDeleteTargetgroup(sess *session.Session, l ...*logger.Logger) *DeleteTargetgroup

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

+ func (cmd *DeleteTargetgroup) ParamsHelp() string

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

+ func (cmd *DeleteTargetgroup) SetApi(api elbv2iface.ELBV2API)

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

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

+ type DeleteTopic struct

+ Id *string

+ func NewDeleteTopic(sess *session.Session, l ...*logger.Logger) *DeleteTopic

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

+ func (cmd *DeleteTopic) ParamsHelp() string

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

+ func (cmd *DeleteTopic) SetApi(api snsiface.SNSAPI)

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

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

+ type DeleteUser struct

+ Name *string

+ func NewDeleteUser(sess *session.Session, l ...*logger.Logger) *DeleteUser

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

+ func (cmd *DeleteUser) ParamsHelp() string

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

+ func (cmd *DeleteUser) SetApi(api iamiface.IAMAPI)

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

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

+ type DeleteVolume struct

+ Id *string

+ func NewDeleteVolume(sess *session.Session, l ...*logger.Logger) *DeleteVolume

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

+ func (cmd *DeleteVolume) ParamsHelp() string

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

+ func (cmd *DeleteVolume) SetApi(api ec2iface.EC2API)

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

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

+ type DeleteVpc struct

+ Id *string

+ func NewDeleteVpc(sess *session.Session, l ...*logger.Logger) *DeleteVpc

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

+ func (cmd *DeleteVpc) ParamsHelp() string

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

+ func (cmd *DeleteVpc) SetApi(api ec2iface.EC2API)

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

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

+ type DeleteZone struct

+ Id *string

+ func NewDeleteZone(sess *session.Session, l ...*logger.Logger) *DeleteZone

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

+ func (cmd *DeleteZone) ParamsHelp() string

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

+ func (cmd *DeleteZone) SetApi(api route53iface.Route53API)

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

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

+ type DetachAlarm struct

+ ActionArn *string

+ Name *string

+ func NewDetachAlarm(sess *session.Session, l ...*logger.Logger) *DetachAlarm

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

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

+ func (cmd *DetachAlarm) ParamsHelp() string

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

+ func (cmd *DetachAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

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

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

+ type DetachContainertask struct

+ ContainerName *string

+ Name *string

+ func NewDetachContainertask(sess *session.Session, l ...*logger.Logger) *DetachContainertask

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

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

+ func (cmd *DetachContainertask) ParamsHelp() string

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

+ func (cmd *DetachContainertask) SetApi(api ecsiface.ECSAPI)

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

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

+ type DetachElasticip struct

+ Association *string

+ func NewDetachElasticip(sess *session.Session, l ...*logger.Logger) *DetachElasticip

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

+ func (cmd *DetachElasticip) ParamsHelp() string

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

+ func (cmd *DetachElasticip) SetApi(api ec2iface.EC2API)

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

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

+ type DetachInstance struct

+ Id *string

+ Targetgroup *string

+ func NewDetachInstance(sess *session.Session, l ...*logger.Logger) *DetachInstance

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

+ func (cmd *DetachInstance) ParamsHelp() string

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

+ func (cmd *DetachInstance) SetApi(api elbv2iface.ELBV2API)

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

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

+ type DetachInstanceprofile struct

+ Instance *string

+ Name *string

+ func NewDetachInstanceprofile(sess *session.Session, l ...*logger.Logger) *DetachInstanceprofile

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

+ func (cmd *DetachInstanceprofile) ExtractResult(i interface{}) string

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

+ func (cmd *DetachInstanceprofile) ParamsHelp() string

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

+ func (cmd *DetachInstanceprofile) SetApi(api ec2iface.EC2API)

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

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

+ type DetachInternetgateway struct

+ Id *string

+ Vpc *string

+ func NewDetachInternetgateway(sess *session.Session, l ...*logger.Logger) *DetachInternetgateway

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

+ func (cmd *DetachInternetgateway) ParamsHelp() string

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

+ func (cmd *DetachInternetgateway) SetApi(api ec2iface.EC2API)

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

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

+ type DetachMfadevice struct

+ Id *string

+ User *string

+ func NewDetachMfadevice(sess *session.Session, l ...*logger.Logger) *DetachMfadevice

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

+ func (cmd *DetachMfadevice) ParamsHelp() string

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

+ func (cmd *DetachMfadevice) SetApi(api iamiface.IAMAPI)

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

+ func (cmd *DetachMfadevice) ValidateParams(params []string) ([]string, error)

+ type DetachNetworkinterface struct

+ func (cmd *DetachNetworkinterface) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachNetworkinterface) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *DetachNetworkinterface) ParamsHelp() string

+ func (cmd *DetachNetworkinterface) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachNetworkinterface) SetApi(api ec2iface.EC2API)

+ func (cmd *DetachNetworkinterface) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *DetachNetworkinterface) ValidateParams(params []string) ([]string, error)

+ Attachment *string

+ Force *bool

+ Id *string

+ Instance *string

+ func NewDetachNetworkinterface(sess *session.Session, l ...*logger.Logger) *DetachNetworkinterface

+ type DetachPolicy struct

+ Arn *string

+ Group *string

+ Role *string

+ User *string

+ func NewDetachPolicy(sess *session.Session, l ...*logger.Logger) *DetachPolicy

+ func (cmd *DetachPolicy) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]interface{}, error))

+ func (cmd *DetachPolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachPolicy) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *DetachPolicy) ParamsHelp() string

+ func (cmd *DetachPolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachPolicy) SetApi(api iamiface.IAMAPI)

+ func (cmd *DetachPolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *DetachPolicy) ValidateParams(params []string) ([]string, error)

+ type DetachRole struct

+ Instanceprofile *string

+ Name *string

+ func NewDetachRole(sess *session.Session, l ...*logger.Logger) *DetachRole

+ func (cmd *DetachRole) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachRole) ParamsHelp() string

+ func (cmd *DetachRole) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachRole) SetApi(api iamiface.IAMAPI)

+ func (cmd *DetachRole) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *DetachRole) ValidateParams(params []string) ([]string, error)

+ type DetachRoutetable struct

+ Association *string

+ func NewDetachRoutetable(sess *session.Session, l ...*logger.Logger) *DetachRoutetable

+ func (cmd *DetachRoutetable) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachRoutetable) ParamsHelp() string

+ func (cmd *DetachRoutetable) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachRoutetable) SetApi(api ec2iface.EC2API)

+ func (cmd *DetachRoutetable) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *DetachRoutetable) ValidateParams(params []string) ([]string, error)

+ type DetachSecuritygroup struct

+ Id *string

+ Instance *string

+ func NewDetachSecuritygroup(sess *session.Session, l ...*logger.Logger) *DetachSecuritygroup

+ func (cmd *DetachSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *DetachSecuritygroup) ParamsHelp() string

+ func (cmd *DetachSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachSecuritygroup) SetApi(api ec2iface.EC2API)

+ func (cmd *DetachSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *DetachSecuritygroup) ValidateParams(params []string) ([]string, error)

+ type DetachUser struct

+ Group *string

+ Name *string

+ func NewDetachUser(sess *session.Session, l ...*logger.Logger) *DetachUser

+ func (cmd *DetachUser) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachUser) ParamsHelp() string

+ func (cmd *DetachUser) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachUser) SetApi(api iamiface.IAMAPI)

+ func (cmd *DetachUser) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *DetachUser) ValidateParams(params []string) ([]string, error)

+ type DetachVolume struct

+ Device *string

+ Force *bool

+ Id *string

+ Instance *string

+ func NewDetachVolume(sess *session.Session, l ...*logger.Logger) *DetachVolume

+ func (cmd *DetachVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachVolume) ExtractResult(i interface{}) string

+ func (cmd *DetachVolume) ParamsHelp() string

+ func (cmd *DetachVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *DetachVolume) SetApi(api ec2iface.EC2API)

+ func (cmd *DetachVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *DetachVolume) ValidateParams(params []string) ([]string, error)

+ type Factory interface

+ Build func(key string) func() interface{}

+ var CommandFactory Factory

+ type ImportImage struct

+ Architecture *string

+ Bucket *string

+ Description *string

+ License *string

+ Platform *string

+ Role *string

+ S3object *string

+ Snapshot *string

+ Url *string

+ func NewImportImage(sess *session.Session, l ...*logger.Logger) *ImportImage

+ func (cmd *ImportImage) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *ImportImage) ExtractResult(i interface{}) string

+ func (cmd *ImportImage) ParamsHelp() string

+ func (cmd *ImportImage) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *ImportImage) SetApi(api ec2iface.EC2API)

+ func (cmd *ImportImage) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *ImportImage) ValidateParams(params []string) ([]string, error)

+ type ProgressReadSeeker struct

+ func NewProgressReader(f *os.File) (*ProgressReadSeeker, error)

+ func (pr *ProgressReadSeeker) Read(p []byte) (int, error)

+ func (pr *ProgressReadSeeker) Seek(offset int64, whence int) (int64, error)

+ type ResultExtractor interface

+ ExtractResult func(interface{}) string

+ type StartAlarm struct

+ Names []*string

+ func NewStartAlarm(sess *session.Session, l ...*logger.Logger) *StartAlarm

+ func (cmd *StartAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StartAlarm) ParamsHelp() string

+ func (cmd *StartAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StartAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

+ func (cmd *StartAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *StartAlarm) ValidateParams(params []string) ([]string, error)

+ type StartContainertask struct

+ Cluster *string

+ DeploymentName *string

+ DesiredCount *int64

+ LoadBalancerContainerName *string

+ LoadBalancerContainerPort *int64

+ LoadBalancerTargetgroup *string

+ Name *string

+ Role *string

+ Type *string

+ func NewStartContainertask(sess *session.Session, l ...*logger.Logger) *StartContainertask

+ func (cmd *StartContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StartContainertask) ExtractResult(i interface{}) string

+ func (cmd *StartContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *StartContainertask) ParamsHelp() string

+ func (cmd *StartContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StartContainertask) SetApi(api ecsiface.ECSAPI)

+ func (cmd *StartContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *StartContainertask) ValidateParams(params []string) ([]string, error)

+ func (cmd *StartContainertask) Validate_Type() error

+ type StartInstance struct

+ Id []*string

+ func NewStartInstance(sess *session.Session, l ...*logger.Logger) *StartInstance

+ func (cmd *StartInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StartInstance) ExtractResult(i interface{}) string

+ func (cmd *StartInstance) ParamsHelp() string

+ func (cmd *StartInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StartInstance) SetApi(api ec2iface.EC2API)

+ func (cmd *StartInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *StartInstance) ValidateParams(params []string) ([]string, error)

+ type StopAlarm struct

+ Names []*string

+ func NewStopAlarm(sess *session.Session, l ...*logger.Logger) *StopAlarm

+ func (cmd *StopAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StopAlarm) ParamsHelp() string

+ func (cmd *StopAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StopAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

+ func (cmd *StopAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *StopAlarm) ValidateParams(params []string) ([]string, error)

+ type StopContainertask struct

+ Cluster *string

+ DeploymentName *string

+ RunArn *string

+ Type *string

+ func NewStopContainertask(sess *session.Session, l ...*logger.Logger) *StopContainertask

+ func (cmd *StopContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StopContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *StopContainertask) ParamsHelp() string

+ func (cmd *StopContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StopContainertask) SetApi(api ecsiface.ECSAPI)

+ func (cmd *StopContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *StopContainertask) ValidateParams(params []string) ([]string, error)

+ func (cmd *StopContainertask) Validate_Type() error

+ type StopInstance struct

+ Id []*string

+ func NewStopInstance(sess *session.Session, l ...*logger.Logger) *StopInstance

+ func (cmd *StopInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StopInstance) ExtractResult(i interface{}) string

+ func (cmd *StopInstance) ParamsHelp() string

+ func (cmd *StopInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *StopInstance) SetApi(api ec2iface.EC2API)

+ func (cmd *StopInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *StopInstance) ValidateParams(params []string) ([]string, error)

+ type UpdateBucket struct

+ Acl *string

+ EnforceHttps *bool

+ IndexSuffix *string

+ Name *string

+ PublicWebsite *bool

+ RedirectHostname *string

+ func NewUpdateBucket(sess *session.Session, l ...*logger.Logger) *UpdateBucket

+ func (cmd *UpdateBucket) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateBucket) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateBucket) ParamsHelp() string

+ func (cmd *UpdateBucket) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateBucket) SetApi(api s3iface.S3API)

+ func (cmd *UpdateBucket) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateBucket) ValidateParams(params []string) ([]string, error)

+ type UpdateContainertask struct

+ Cluster *string

+ DeploymentName *string

+ DesiredCount *int64

+ Name *string

+ func NewUpdateContainertask(sess *session.Session, l ...*logger.Logger) *UpdateContainertask

+ func (cmd *UpdateContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateContainertask) ParamsHelp() string

+ func (cmd *UpdateContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateContainertask) SetApi(api ecsiface.ECSAPI)

+ func (cmd *UpdateContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateContainertask) ValidateParams(params []string) ([]string, error)

+ type UpdateDistribution struct

+ Enable *bool

+ Id *string

+ func NewUpdateDistribution(sess *session.Session, l ...*logger.Logger) *UpdateDistribution

+ func (cmd *UpdateDistribution) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateDistribution) ExtractResult(i interface{}) string

+ func (cmd *UpdateDistribution) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateDistribution) ParamsHelp() string

+ func (cmd *UpdateDistribution) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateDistribution) SetApi(api cloudfrontiface.CloudFrontAPI)

+ func (cmd *UpdateDistribution) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateDistribution) ValidateParams(params []string) ([]string, error)

+ type UpdateInstance struct

+ Id *string

+ Lock *bool

+ Type *string

+ func NewUpdateInstance(sess *session.Session, l ...*logger.Logger) *UpdateInstance

+ func (cmd *UpdateInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateInstance) ParamsHelp() string

+ func (cmd *UpdateInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateInstance) SetApi(api ec2iface.EC2API)

+ func (cmd *UpdateInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateInstance) ValidateParams(params []string) ([]string, error)

+ type UpdateLoginprofile struct

+ Password *string

+ PasswordReset *bool

+ Username *string

+ func NewUpdateLoginprofile(sess *session.Session, l ...*logger.Logger) *UpdateLoginprofile

+ func (cmd *UpdateLoginprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateLoginprofile) ParamsHelp() string

+ func (cmd *UpdateLoginprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateLoginprofile) SetApi(api iamiface.IAMAPI)

+ func (cmd *UpdateLoginprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateLoginprofile) ValidateParams(params []string) ([]string, error)

+ type UpdatePolicy struct

+ Action []*string

+ Arn *string

+ Conditions []*string

+ DefaultVersion *bool

+ Document *string

+ Effect *string

+ Resource []*string

+ func NewUpdatePolicy(sess *session.Session, l ...*logger.Logger) *UpdatePolicy

+ func (cmd *UpdatePolicy) BeforeRun(ctx map[string]interface{}) error

+ func (cmd *UpdatePolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdatePolicy) ParamsHelp() string

+ func (cmd *UpdatePolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdatePolicy) SetApi(api iamiface.IAMAPI)

+ func (cmd *UpdatePolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdatePolicy) ValidateParams(params []string) ([]string, error)

+ type UpdateRecord struct

+ Name *string

+ Ttl *int64

+ Type *string

+ Value *string

+ Zone *string

+ func NewUpdateRecord(sess *session.Session, l ...*logger.Logger) *UpdateRecord

+ func (cmd *UpdateRecord) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateRecord) ExtractResult(i interface{}) string

+ func (cmd *UpdateRecord) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateRecord) ParamsHelp() string

+ func (cmd *UpdateRecord) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateRecord) SetApi(api route53iface.Route53API)

+ func (cmd *UpdateRecord) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateRecord) ValidateParams(params []string) ([]string, error)

+ type UpdateS3object struct

+ Acl *string

+ Bucket *string

+ Name *string

+ Version *string

+ func NewUpdateS3object(sess *session.Session, l ...*logger.Logger) *UpdateS3object

+ func (cmd *UpdateS3object) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateS3object) ParamsHelp() string

+ func (cmd *UpdateS3object) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateS3object) SetApi(api s3iface.S3API)

+ func (cmd *UpdateS3object) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateS3object) ValidateParams(params []string) ([]string, error)

+ type UpdateScalinggroup struct

+ Cooldown *int64

+ DesiredCapacity *int64

+ HealthcheckGracePeriod *int64

+ HealthcheckType *string

+ Launchconfiguration *string

+ MaxSize *int64

+ MinSize *int64

+ Name *string

+ NewInstancesProtected *bool

+ Subnets []*string

+ func NewUpdateScalinggroup(sess *session.Session, l ...*logger.Logger) *UpdateScalinggroup

+ func (cmd *UpdateScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateScalinggroup) ParamsHelp() string

+ func (cmd *UpdateScalinggroup) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateScalinggroup) SetApi(api autoscalingiface.AutoScalingAPI)

+ func (cmd *UpdateScalinggroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateScalinggroup) ValidateParams(params []string) ([]string, error)

+ type UpdateSecuritygroup struct

+ CIDR *string

+ Id *string

+ Inbound *string

+ Outbound *string

+ Portrange *string

+ Protocol *string

+ Securitygroup *string

+ func NewUpdateSecuritygroup(sess *session.Session, l ...*logger.Logger) *UpdateSecuritygroup

+ func (cmd *UpdateSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateSecuritygroup) ParamsHelp() string

+ func (cmd *UpdateSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateSecuritygroup) SetApi(api ec2iface.EC2API)

+ func (cmd *UpdateSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateSecuritygroup) ValidateParams(params []string) ([]string, error)

+ func (cmd *UpdateSecuritygroup) Validate_CIDR() error

+ func (cmd *UpdateSecuritygroup) Validate_Inbound() error

+ func (cmd *UpdateSecuritygroup) Validate_Outbound() error

+ type UpdateStack struct

+ Capabilities []*string

+ Name *string

+ Notifications []*string

+ Parameters []*string

+ PolicyFile *string

+ PolicyUpdateFile *string

+ ResourceTypes []*string

+ Role *string

+ TemplateFile *string

+ UsePreviousTemplate *bool

+ func NewUpdateStack(sess *session.Session, l ...*logger.Logger) *UpdateStack

+ func (cmd *UpdateStack) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateStack) ExtractResult(i interface{}) string

+ func (cmd *UpdateStack) ParamsHelp() string

+ func (cmd *UpdateStack) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateStack) SetApi(api cloudformationiface.CloudFormationAPI)

+ func (cmd *UpdateStack) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateStack) ValidateParams(params []string) ([]string, error)

+ type UpdateSubnet struct

+ Id *string

+ Public *bool

+ func NewUpdateSubnet(sess *session.Session, l ...*logger.Logger) *UpdateSubnet

+ func (cmd *UpdateSubnet) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateSubnet) ParamsHelp() string

+ func (cmd *UpdateSubnet) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateSubnet) SetApi(api ec2iface.EC2API)

+ func (cmd *UpdateSubnet) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateSubnet) ValidateParams(params []string) ([]string, error)

+ type UpdateTargetgroup struct

+ Deregistrationdelay *string

+ Healthcheckinterval *int64

+ Healthcheckpath *string

+ Healthcheckport *string

+ Healthcheckprotocol *string

+ Healthchecktimeout *int64

+ Healthythreshold *int64

+ Id *string

+ Matcher *string

+ Stickiness *string

+ Stickinessduration *string

+ Unhealthythreshold *int64

+ func NewUpdateTargetgroup(sess *session.Session, l ...*logger.Logger) *UpdateTargetgroup

+ func (cmd *UpdateTargetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateTargetgroup) ParamsHelp() string

+ func (cmd *UpdateTargetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

+ func (cmd *UpdateTargetgroup) SetApi(api elbv2iface.ELBV2API)

+ func (cmd *UpdateTargetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

+ func (cmd *UpdateTargetgroup) ValidateParams(params []string) ([]string, error)

+ func (tg *UpdateTargetgroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL