awsspec

Documentation

Overview

DO NOT EDIT This file was automatically generated with go generate

DO NOT EDIT This file was automatically generated with go generate

DO NOT EDIT This file was automatically generated with go generate

Copyright 2017 WALLIX

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

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

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

Copyright 2017 WALLIX

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

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

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

Copyright 2017 WALLIX

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

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

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

Copyright 2017 WALLIX

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

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

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

Index

• Constants
• Variables
• 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
  • func (f *AWSFactory) Build(key string) func() interface{}
• type AfterRunner
• type AttachAlarm
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func NewAttachNetworkinterface(sess *session.Session, l ...*logger.Logger) *AttachNetworkinterface
  • 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)
• type AttachPolicy
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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 AwsImage
• type BeforeRunner
• type CheckCertificate
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func NewCheckNetworkinterface(sess *session.Session, l ...*logger.Logger) *CheckNetworkinterface
  • 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
• type CheckScalinggroup
  • func NewCheckScalinggroup(sess *session.Session, l ...*logger.Logger) *CheckScalinggroup
  • func (cmd *CheckScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)
  • func (sg *CheckScalinggroup) ManualRun(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)
• type CheckSecuritygroup
  • 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
  • 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
  • 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
  • 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
  • func NewCreateAccesskey(sess *session.Session, l ...*logger.Logger) *CreateAccesskey
  • func (cmd *CreateAccesskey) AfterRun(ctx map[string]interface{}, output interface{}) error
  • func (cmd *CreateAccesskey) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func NewCreateInstance(sess *session.Session, l ...*logger.Logger) *CreateInstance
  • func (cmd *CreateInstance) AfterRun(ctx map[string]interface{}, output interface{}) error
  • func (cmd *CreateInstance) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]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
  • 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
  • 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
  • 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
  • func NewCreateLaunchconfiguration(sess *session.Session, l ...*logger.Logger) *CreateLaunchconfiguration
  • func (cmd *CreateLaunchconfiguration) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]interface{}, error))
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func NewCreateNetworkinterface(sess *session.Session, l ...*logger.Logger) *CreateNetworkinterface
  • 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)
• type CreatePolicy
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func AWSLookupDefinitions(key string) (t Definition, ok bool)
• type DeleteAccesskey
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func NewDeleteNetworkinterface(sess *session.Session, l ...*logger.Logger) *DeleteNetworkinterface
  • 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)
• type DeletePolicy
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func NewDetachNetworkinterface(sess *session.Session, l ...*logger.Logger) *DetachNetworkinterface
  • 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)
• type DetachPolicy
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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 Distro
• type Factory
• type ImageQuery
  • func ParseImageQuery(s string) (ImageQuery, error)
  • func (q ImageQuery) String() string
• type ImageResolver
  • func EC2ImageResolver() ImageResolver
  • func (resolv ImageResolver) Resolve(q ImageQuery) ([]*AwsImage, bool, error)
• type ImageResolverCache
  • func (r *ImageResolverCache) Get(key string) ([]*AwsImage, bool)
  • func (r *ImageResolverCache) Store(key string, images []*AwsImage)
• type ImportImage
  • 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 Platform
• type ProgressReadSeeker
  • 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
• type StartAlarm
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • func NewUpdateTargetgroup(sess *session.Session, l ...*logger.Logger) *UpdateTargetgroup
  • func (cmd *UpdateTargetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)
  • func (tg *UpdateTargetgroup) ManualRun(ctx 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)

Constants

const ImageQuerySpec = "owner:distro:variant:arch:virtualization:store"

Variables

var (
	Platforms = map[string]Platform{
		"canonical":   Canonical,
		"redhat":      RedHat,
		"debian":      Debian,
		"amazonlinux": AmazonLinux,
		"suselinux":   SuseLinux,
		"windows":     Windows,
	}

	Canonical = Platform{
		Name: "canonical", Id: "099720109477", DistroName: "ubuntu", LatestVariant: "xenial",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, fmt.Sprintf("%s/images/%s-ssd/%s-%s", d.Name, d.Virt, d.Name, d.Variant))
		},
	}

	RedHat = Platform{
		Name: "redhat", Id: "309956199498", DistroName: "rhel", LatestVariant: "7.3",
		MatchFunc: func(s string, d Distro) bool {
			return strings.Contains(s, fmt.Sprintf("%s-%s", d.Name, d.Variant))
		},
	}

	Debian = Platform{
		Name: "debian", Id: "379101102735", DistroName: "debian", LatestVariant: "jessie",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, fmt.Sprintf("%s-%s", d.Name, d.Variant))
		},
	}

	AmazonLinux = Platform{
		Name: "amazonlinux", Id: "137112412989", LatestVariant: "hvm",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, fmt.Sprintf("amzn-ami-%s", d.Variant))
		},
	}

	SuseLinux = Platform{
		Name: "suselinux", Id: "013907871322", LatestVariant: "sles-12",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, fmt.Sprintf("suse-%s", d.Variant))
		},
	}

	Windows = Platform{
		Name: "windows", Id: "801119661308", DistroName: "server", LatestVariant: "2016",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, strings.ToLower(fmt.Sprintf("windows_%s-%s-english", d.Name, d.Variant)))
		},
	}

	SupportedAMIOwners []string
)

var APIPerTemplateDefName = map[string]string{}/* 155 elements not displayed */

var (
	AWSCredFilepath = filepath.Join(awsconfig.AWSHomeDir(), "credentials")
)

var AWSTemplatesDefinitions = map[string]Definition{}/* 155 elements not displayed */

var CallerReferenceFunc = func() string {
	return fmt.Sprint(time.Now().UTC().Unix())
}

var DefaultImageResolverCache = new(ImageResolverCache)

var DriverSupportedActions = map[string][]string{
	"attach":       {"alarm", "containertask", "elasticip", "instance", "instanceprofile", "internetgateway", "mfadevice", "networkinterface", "policy", "role", "routetable", "securitygroup", "user", "volume"},
	"authenticate": {"registry"},
	"check":        {"certificate", "database", "distribution", "instance", "loadbalancer", "natgateway", "networkinterface", "scalinggroup", "securitygroup", "volume"},
	"copy":         {"image", "snapshot"},
	"create":       {"accesskey", "alarm", "appscalingpolicy", "appscalingtarget", "bucket", "certificate", "containercluster", "database", "dbsubnetgroup", "distribution", "elasticip", "function", "group", "instance", "instanceprofile", "internetgateway", "keypair", "launchconfiguration", "listener", "loadbalancer", "loginprofile", "mfadevice", "natgateway", "networkinterface", "policy", "queue", "record", "repository", "role", "route", "routetable", "s3object", "scalinggroup", "scalingpolicy", "securitygroup", "snapshot", "stack", "subnet", "subscription", "tag", "targetgroup", "topic", "user", "volume", "vpc", "zone"},
	"delete":       {"accesskey", "alarm", "appscalingpolicy", "appscalingtarget", "bucket", "certificate", "containercluster", "containertask", "database", "dbsubnetgroup", "distribution", "elasticip", "function", "group", "image", "instance", "instanceprofile", "internetgateway", "keypair", "launchconfiguration", "listener", "loadbalancer", "loginprofile", "mfadevice", "natgateway", "networkinterface", "policy", "queue", "record", "repository", "role", "route", "routetable", "s3object", "scalinggroup", "scalingpolicy", "securitygroup", "snapshot", "stack", "subnet", "subscription", "tag", "targetgroup", "topic", "user", "volume", "vpc", "zone"},
	"detach":       {"alarm", "containertask", "elasticip", "instance", "instanceprofile", "internetgateway", "mfadevice", "networkinterface", "policy", "role", "routetable", "securitygroup", "user", "volume"},
	"import":       {"image"},
	"start":        {"alarm", "containertask", "instance"},
	"stop":         {"alarm", "containertask", "instance"},
	"update":       {"bucket", "containertask", "distribution", "instance", "loginprofile", "policy", "record", "s3object", "scalinggroup", "securitygroup", "stack", "subnet", "targetgroup"},
}

var MockAWSSessionFactory = &AWSFactory{
	Log:  logger.DiscardLogger,
	Sess: mock.Session,
}

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

Allow to control for testing

Functions

func Bool

func Bool(v bool) *bool

func BoolValue

func BoolValue(v *bool) bool

func Int64

func Int64(v int64) *int64

func Int64AsIntValue

func Int64AsIntValue(v *int64) int

func NewCredsPrompter

func NewCredsPrompter(profile string) *credentialsPrompter

func NewEnumValidator

func NewEnumValidator(expected ...string) *enumValidator

func String

func String(v string) *string

func StringValue

func StringValue(v *string) string

Types

type AWSFactory

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

func (*AWSFactory) Build

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

type AfterRunner

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

type AttachAlarm

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

func NewAttachAlarm

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

func (*AttachAlarm) DryRun

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

func (*AttachAlarm) ManualRun

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

func (*AttachAlarm) ParamsHelp

func (cmd *AttachAlarm) ParamsHelp() string

func (*AttachAlarm) Run

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

func (*AttachAlarm) SetApi

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

func (*AttachAlarm) ValidateCommand

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

func (*AttachAlarm) ValidateParams

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

type AttachContainertask

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

func NewAttachContainertask

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

func (*AttachContainertask) DryRun

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

func (*AttachContainertask) ExtractResult

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

func (*AttachContainertask) ManualRun

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

func (*AttachContainertask) ParamsHelp

func (cmd *AttachContainertask) ParamsHelp() string

func (*AttachContainertask) Run

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

func (*AttachContainertask) SetApi

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

func (*AttachContainertask) ValidateCommand

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

func (*AttachContainertask) ValidateParams

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

type AttachElasticip

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

func NewAttachElasticip

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

func (*AttachElasticip) DryRun

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

func (*AttachElasticip) ExtractResult

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

func (*AttachElasticip) ParamsHelp

func (cmd *AttachElasticip) ParamsHelp() string

func (*AttachElasticip) Run

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

func (*AttachElasticip) SetApi

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

func (*AttachElasticip) ValidateCommand

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

func (*AttachElasticip) ValidateParams

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

type AttachInstance

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

func NewAttachInstance

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

func (*AttachInstance) DryRun

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

func (*AttachInstance) ParamsHelp

func (cmd *AttachInstance) ParamsHelp() string

func (*AttachInstance) Run

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

func (*AttachInstance) SetApi

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

func (*AttachInstance) ValidateCommand

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

func (*AttachInstance) ValidateParams

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

type AttachInstanceprofile

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

func NewAttachInstanceprofile

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

func (*AttachInstanceprofile) DryRun

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

func (*AttachInstanceprofile) ManualRun

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

func (*AttachInstanceprofile) ParamsHelp

func (cmd *AttachInstanceprofile) ParamsHelp() string

func (*AttachInstanceprofile) Run

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

func (*AttachInstanceprofile) SetApi

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

func (*AttachInstanceprofile) ValidateCommand

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

func (*AttachInstanceprofile) ValidateParams

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

type AttachInternetgateway

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

func NewAttachInternetgateway

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

func (*AttachInternetgateway) DryRun

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

func (*AttachInternetgateway) ParamsHelp

func (cmd *AttachInternetgateway) ParamsHelp() string

func (*AttachInternetgateway) Run

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

func (*AttachInternetgateway) SetApi

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

func (*AttachInternetgateway) ValidateCommand

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

func (*AttachInternetgateway) ValidateParams

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

type AttachMfadevice

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

func NewAttachMfadevice

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

func (*AttachMfadevice) AfterRun

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

func (*AttachMfadevice) DryRun

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

func (*AttachMfadevice) ParamsHelp

func (cmd *AttachMfadevice) ParamsHelp() string

func (*AttachMfadevice) Run

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

func (*AttachMfadevice) SetApi

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

func (*AttachMfadevice) ValidateCommand

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

func (*AttachMfadevice) ValidateParams

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

type AttachNetworkinterface

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

func NewAttachNetworkinterface

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

func (*AttachNetworkinterface) DryRun

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

func (*AttachNetworkinterface) ExtractResult

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

func (*AttachNetworkinterface) ParamsHelp

func (cmd *AttachNetworkinterface) ParamsHelp() string

func (*AttachNetworkinterface) Run

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

func (*AttachNetworkinterface) SetApi

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

func (*AttachNetworkinterface) ValidateCommand

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

func (*AttachNetworkinterface) ValidateParams

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

type AttachPolicy

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

func NewAttachPolicy

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

func (*AttachPolicy) ConvertParams

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

func (*AttachPolicy) DryRun

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

func (*AttachPolicy) ManualRun

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

func (*AttachPolicy) ParamsHelp

func (cmd *AttachPolicy) ParamsHelp() string

func (*AttachPolicy) Run

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

func (*AttachPolicy) SetApi

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

func (*AttachPolicy) ValidateCommand

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

func (*AttachPolicy) ValidateParams

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

type AttachRole

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

func NewAttachRole

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

func (*AttachRole) DryRun

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

func (*AttachRole) ParamsHelp

func (cmd *AttachRole) ParamsHelp() string

func (*AttachRole) Run

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

func (*AttachRole) SetApi

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

func (*AttachRole) ValidateCommand

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

func (*AttachRole) ValidateParams

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

type AttachRoutetable

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

func NewAttachRoutetable

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

func (*AttachRoutetable) DryRun

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

func (*AttachRoutetable) ExtractResult

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

func (*AttachRoutetable) ParamsHelp

func (cmd *AttachRoutetable) ParamsHelp() string

func (*AttachRoutetable) Run

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

func (*AttachRoutetable) SetApi

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

func (*AttachRoutetable) ValidateCommand

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

func (*AttachRoutetable) ValidateParams

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

type AttachSecuritygroup

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

func NewAttachSecuritygroup

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

func (*AttachSecuritygroup) DryRun

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

func (*AttachSecuritygroup) ManualRun

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

func (*AttachSecuritygroup) ParamsHelp

func (cmd *AttachSecuritygroup) ParamsHelp() string

func (*AttachSecuritygroup) Run

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

func (*AttachSecuritygroup) SetApi

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

func (*AttachSecuritygroup) ValidateCommand

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

func (*AttachSecuritygroup) ValidateParams

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

type AttachUser

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

func NewAttachUser

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

func (*AttachUser) DryRun

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

func (*AttachUser) ParamsHelp

func (cmd *AttachUser) ParamsHelp() string

func (*AttachUser) Run

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

func (*AttachUser) SetApi

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

func (*AttachUser) ValidateCommand

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

func (*AttachUser) ValidateParams

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

type AttachVolume

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

func NewAttachVolume

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

func (*AttachVolume) DryRun

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

func (*AttachVolume) ExtractResult

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

func (*AttachVolume) ParamsHelp

func (cmd *AttachVolume) ParamsHelp() string

func (*AttachVolume) Run

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

func (*AttachVolume) SetApi

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

func (*AttachVolume) ValidateCommand

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

func (*AttachVolume) ValidateParams

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

type AuthenticateRegistry

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

func NewAuthenticateRegistry

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

func (*AuthenticateRegistry) DryRun

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

func (*AuthenticateRegistry) ManualRun

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

func (*AuthenticateRegistry) ParamsHelp

func (cmd *AuthenticateRegistry) ParamsHelp() string

func (*AuthenticateRegistry) Run

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

func (*AuthenticateRegistry) SetApi

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

func (*AuthenticateRegistry) ValidateCommand

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

func (*AuthenticateRegistry) ValidateParams

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

type AwsImage

type AwsImage struct {
	Id                 string
	Owner              string
	Location           string
	Type               string
	Architecture       string
	VirtualizationType string
	Name               string
	Created            time.Time
	Hypervisor         string
	Store              string
}

type BeforeRunner

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

type CheckCertificate

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

func NewCheckCertificate

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

func (*CheckCertificate) DryRun

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

func (*CheckCertificate) ManualRun

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

func (*CheckCertificate) ParamsHelp

func (cmd *CheckCertificate) ParamsHelp() string

func (*CheckCertificate) Run

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

func (*CheckCertificate) SetApi

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

func (*CheckCertificate) ValidateCommand

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

func (*CheckCertificate) ValidateParams

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

func (*CheckCertificate) Validate_State

func (cmd *CheckCertificate) Validate_State() error

type CheckDatabase

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

func NewCheckDatabase

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

func (*CheckDatabase) DryRun

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

func (*CheckDatabase) ManualRun

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

func (*CheckDatabase) ParamsHelp

func (cmd *CheckDatabase) ParamsHelp() string

func (*CheckDatabase) Run

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

func (*CheckDatabase) SetApi

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

func (*CheckDatabase) ValidateCommand

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

func (*CheckDatabase) ValidateParams

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

func (*CheckDatabase) Validate_State

func (cmd *CheckDatabase) Validate_State() error

type CheckDistribution

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

func NewCheckDistribution

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

func (*CheckDistribution) DryRun

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

func (*CheckDistribution) ManualRun

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

func (*CheckDistribution) ParamsHelp

func (cmd *CheckDistribution) ParamsHelp() string

func (*CheckDistribution) Run

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

func (*CheckDistribution) SetApi

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

func (*CheckDistribution) ValidateCommand

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

func (*CheckDistribution) ValidateParams

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

func (*CheckDistribution) Validate_State

func (cmd *CheckDistribution) Validate_State() error

type CheckInstance

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

func NewCheckInstance

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

func (*CheckInstance) DryRun

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

func (*CheckInstance) ManualRun

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

func (*CheckInstance) ParamsHelp

func (cmd *CheckInstance) ParamsHelp() string

func (*CheckInstance) Run

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

func (*CheckInstance) SetApi

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

func (*CheckInstance) ValidateCommand

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

func (*CheckInstance) ValidateParams

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

func (*CheckInstance) Validate_State

func (cmd *CheckInstance) Validate_State() error

type CheckLoadbalancer

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

func NewCheckLoadbalancer

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

func (*CheckLoadbalancer) DryRun

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

func (*CheckLoadbalancer) ManualRun

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

func (*CheckLoadbalancer) ParamsHelp

func (cmd *CheckLoadbalancer) ParamsHelp() string

func (*CheckLoadbalancer) Run

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

func (*CheckLoadbalancer) SetApi

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

func (*CheckLoadbalancer) ValidateCommand

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

func (*CheckLoadbalancer) ValidateParams

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

func (*CheckLoadbalancer) Validate_State

func (cmd *CheckLoadbalancer) Validate_State() error

type CheckNatgateway

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

func NewCheckNatgateway

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

func (*CheckNatgateway) DryRun

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

func (*CheckNatgateway) ManualRun

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

func (*CheckNatgateway) ParamsHelp

func (cmd *CheckNatgateway) ParamsHelp() string

func (*CheckNatgateway) Run

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

func (*CheckNatgateway) SetApi

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

func (*CheckNatgateway) ValidateCommand

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

func (*CheckNatgateway) ValidateParams

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

func (*CheckNatgateway) Validate_State

func (cmd *CheckNatgateway) Validate_State() error

type CheckNetworkinterface

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

func NewCheckNetworkinterface

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

func (*CheckNetworkinterface) DryRun

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

func (*CheckNetworkinterface) ManualRun

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

func (*CheckNetworkinterface) ParamsHelp

func (cmd *CheckNetworkinterface) ParamsHelp() string

func (*CheckNetworkinterface) Run

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

func (*CheckNetworkinterface) SetApi

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

func (*CheckNetworkinterface) ValidateCommand

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

func (*CheckNetworkinterface) ValidateParams

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

func (*CheckNetworkinterface) Validate_State

func (cmd *CheckNetworkinterface) Validate_State() error

type CheckScalinggroup

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

func NewCheckScalinggroup

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

func (*CheckScalinggroup) DryRun

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

func (*CheckScalinggroup) ManualRun

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

func (*CheckScalinggroup) ParamsHelp

func (cmd *CheckScalinggroup) ParamsHelp() string

func (*CheckScalinggroup) Run

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

func (*CheckScalinggroup) SetApi

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

func (*CheckScalinggroup) ValidateCommand

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

func (*CheckScalinggroup) ValidateParams

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

type CheckSecuritygroup

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

func NewCheckSecuritygroup

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

func (*CheckSecuritygroup) DryRun

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

func (*CheckSecuritygroup) ManualRun

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

func (*CheckSecuritygroup) ParamsHelp

func (cmd *CheckSecuritygroup) ParamsHelp() string

func (*CheckSecuritygroup) Run

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

func (*CheckSecuritygroup) SetApi

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

func (*CheckSecuritygroup) ValidateCommand

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

func (*CheckSecuritygroup) ValidateParams

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

func (*CheckSecuritygroup) Validate_State

func (cmd *CheckSecuritygroup) Validate_State() error

type CheckVolume

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

func NewCheckVolume

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

func (*CheckVolume) DryRun

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

func (*CheckVolume) ManualRun

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

func (*CheckVolume) ParamsHelp

func (cmd *CheckVolume) ParamsHelp() string

func (*CheckVolume) Run

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

func (*CheckVolume) SetApi

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

func (*CheckVolume) ValidateCommand

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

func (*CheckVolume) ValidateParams

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

func (*CheckVolume) Validate_State

func (cmd *CheckVolume) Validate_State() error

type CopyImage

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

func NewCopyImage

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

func (*CopyImage) DryRun

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

func (*CopyImage) ExtractResult

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

func (*CopyImage) ParamsHelp

func (cmd *CopyImage) ParamsHelp() string

func (*CopyImage) Run

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

func (*CopyImage) SetApi

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

func (*CopyImage) ValidateCommand

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

func (*CopyImage) ValidateParams

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

type CopySnapshot

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

func NewCopySnapshot

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

func (*CopySnapshot) DryRun

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

func (*CopySnapshot) ExtractResult

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

func (*CopySnapshot) ParamsHelp

func (cmd *CopySnapshot) ParamsHelp() string

func (*CopySnapshot) Run

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

func (*CopySnapshot) SetApi

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

func (*CopySnapshot) ValidateCommand

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

func (*CopySnapshot) ValidateParams

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

type CreateAccesskey

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

func NewCreateAccesskey

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

func (*CreateAccesskey) AfterRun

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

func (*CreateAccesskey) ConvertParams

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

func (*CreateAccesskey) DryRun

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

func (*CreateAccesskey) ExtractResult

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

func (*CreateAccesskey) ParamsHelp

func (cmd *CreateAccesskey) ParamsHelp() string

func (*CreateAccesskey) Run

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

func (*CreateAccesskey) SetApi

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

func (*CreateAccesskey) ValidateCommand

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

func (*CreateAccesskey) ValidateParams

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

type CreateAlarm

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

func NewCreateAlarm

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

func (*CreateAlarm) DryRun

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

func (*CreateAlarm) ExtractResult

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

func (*CreateAlarm) ParamsHelp

func (cmd *CreateAlarm) ParamsHelp() string

func (*CreateAlarm) Run

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

func (*CreateAlarm) SetApi

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

func (*CreateAlarm) ValidateCommand

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

func (*CreateAlarm) ValidateParams

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

func (*CreateAlarm) Validate_Operator

func (cmd *CreateAlarm) Validate_Operator() error

type CreateAppscalingpolicy

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

func NewCreateAppscalingpolicy

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

func (*CreateAppscalingpolicy) DryRun

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

func (*CreateAppscalingpolicy) ExtractResult

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

func (*CreateAppscalingpolicy) ParamsHelp

func (cmd *CreateAppscalingpolicy) ParamsHelp() string

func (*CreateAppscalingpolicy) Run

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

func (*CreateAppscalingpolicy) SetApi

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

func (*CreateAppscalingpolicy) ValidateCommand

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

func (*CreateAppscalingpolicy) ValidateParams

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

type CreateAppscalingtarget

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

func NewCreateAppscalingtarget

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

func (*CreateAppscalingtarget) DryRun

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

func (*CreateAppscalingtarget) ParamsHelp

func (cmd *CreateAppscalingtarget) ParamsHelp() string

func (*CreateAppscalingtarget) Run

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

func (*CreateAppscalingtarget) SetApi

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

func (*CreateAppscalingtarget) ValidateCommand

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

func (*CreateAppscalingtarget) ValidateParams

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

type CreateBucket

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

func NewCreateBucket

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

func (*CreateBucket) DryRun

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

func (*CreateBucket) ExtractResult

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

func (*CreateBucket) ParamsHelp

func (cmd *CreateBucket) ParamsHelp() string

func (*CreateBucket) Run

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

func (*CreateBucket) SetApi

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

func (*CreateBucket) ValidateCommand

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

func (*CreateBucket) ValidateParams

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

type CreateCertificate

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

func NewCreateCertificate

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

func (*CreateCertificate) DryRun

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

func (*CreateCertificate) ExtractResult

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

func (*CreateCertificate) ManualRun

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

func (*CreateCertificate) ParamsHelp

func (cmd *CreateCertificate) ParamsHelp() string

func (*CreateCertificate) Run

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

func (*CreateCertificate) SetApi

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

func (*CreateCertificate) ValidateCommand

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

func (*CreateCertificate) ValidateParams

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

type CreateContainercluster

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

func NewCreateContainercluster

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

func (*CreateContainercluster) DryRun

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

func (*CreateContainercluster) ExtractResult

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

func (*CreateContainercluster) ParamsHelp

func (cmd *CreateContainercluster) ParamsHelp() string

func (*CreateContainercluster) Run

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

func (*CreateContainercluster) SetApi

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

func (*CreateContainercluster) ValidateCommand

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

func (*CreateContainercluster) ValidateParams

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

type CreateDatabase

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

func NewCreateDatabase

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

func (*CreateDatabase) DryRun

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

func (*CreateDatabase) ExtractResult

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

func (*CreateDatabase) ParamsHelp

func (cmd *CreateDatabase) ParamsHelp() string

func (*CreateDatabase) Run

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

func (*CreateDatabase) SetApi

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

func (*CreateDatabase) ValidateCommand

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

func (*CreateDatabase) ValidateParams

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

type CreateDbsubnetgroup

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

func NewCreateDbsubnetgroup

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

func (*CreateDbsubnetgroup) DryRun

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

func (*CreateDbsubnetgroup) ExtractResult

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

func (*CreateDbsubnetgroup) ParamsHelp

func (cmd *CreateDbsubnetgroup) ParamsHelp() string

func (*CreateDbsubnetgroup) Run

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

func (*CreateDbsubnetgroup) SetApi

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

func (*CreateDbsubnetgroup) ValidateCommand

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

func (*CreateDbsubnetgroup) ValidateParams

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

type CreateDistribution

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

func NewCreateDistribution

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

func (*CreateDistribution) DryRun

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

func (*CreateDistribution) ExtractResult

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

func (*CreateDistribution) ManualRun

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

func (*CreateDistribution) ParamsHelp

func (cmd *CreateDistribution) ParamsHelp() string

func (*CreateDistribution) Run

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

func (*CreateDistribution) SetApi

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

func (*CreateDistribution) ValidateCommand

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

func (*CreateDistribution) ValidateParams

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

type CreateElasticip

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

func NewCreateElasticip

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

func (*CreateElasticip) DryRun

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

func (*CreateElasticip) ExtractResult

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

func (*CreateElasticip) ParamsHelp

func (cmd *CreateElasticip) ParamsHelp() string

func (*CreateElasticip) Run

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

func (*CreateElasticip) SetApi

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

func (*CreateElasticip) ValidateCommand

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

func (*CreateElasticip) ValidateParams

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

type CreateFunction

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

func NewCreateFunction

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

func (*CreateFunction) DryRun

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

func (*CreateFunction) ExtractResult

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

func (*CreateFunction) ParamsHelp

func (cmd *CreateFunction) ParamsHelp() string

func (*CreateFunction) Run

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

func (*CreateFunction) SetApi

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

func (*CreateFunction) ValidateCommand

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

func (*CreateFunction) ValidateParams

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

type CreateGroup

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

func NewCreateGroup

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

func (*CreateGroup) DryRun

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

func (*CreateGroup) ExtractResult

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

func (*CreateGroup) ParamsHelp

func (cmd *CreateGroup) ParamsHelp() string

func (*CreateGroup) Run

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

func (*CreateGroup) SetApi

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

func (*CreateGroup) ValidateCommand

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

func (*CreateGroup) ValidateParams

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

type CreateInstance

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

func NewCreateInstance

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

func (*CreateInstance) AfterRun

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

func (*CreateInstance) ConvertParams

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

func (*CreateInstance) DryRun

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

func (*CreateInstance) ExtractResult

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

func (*CreateInstance) ParamsHelp

func (cmd *CreateInstance) ParamsHelp() string

func (*CreateInstance) Run

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

func (*CreateInstance) SetApi

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

func (*CreateInstance) ValidateCommand

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

func (*CreateInstance) ValidateParams

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

type CreateInstanceprofile

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

func NewCreateInstanceprofile

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

func (*CreateInstanceprofile) DryRun

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

func (*CreateInstanceprofile) ParamsHelp

func (cmd *CreateInstanceprofile) ParamsHelp() string

func (*CreateInstanceprofile) Run

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

func (*CreateInstanceprofile) SetApi

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

func (*CreateInstanceprofile) ValidateCommand

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

func (*CreateInstanceprofile) ValidateParams

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

type CreateInternetgateway

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

func NewCreateInternetgateway

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

func (*CreateInternetgateway) DryRun

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

func (*CreateInternetgateway) ExtractResult

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

func (*CreateInternetgateway) ParamsHelp

func (cmd *CreateInternetgateway) ParamsHelp() string

func (*CreateInternetgateway) Run

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

func (*CreateInternetgateway) SetApi

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

func (*CreateInternetgateway) ValidateCommand

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

func (*CreateInternetgateway) ValidateParams

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

type CreateKeypair

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

func NewCreateKeypair

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

func (*CreateKeypair) BeforeRun

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

func (*CreateKeypair) DryRun

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

func (*CreateKeypair) ExtractResult

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

func (*CreateKeypair) ParamsHelp

func (cmd *CreateKeypair) ParamsHelp() string

func (*CreateKeypair) Run

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

func (*CreateKeypair) SetApi

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

func (*CreateKeypair) ValidateCommand

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

func (*CreateKeypair) ValidateParams

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

func (*CreateKeypair) Validate_Name

func (cmd *CreateKeypair) Validate_Name() error

type CreateLaunchconfiguration

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

func NewCreateLaunchconfiguration

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

func (*CreateLaunchconfiguration) ConvertParams

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

func (*CreateLaunchconfiguration) DryRun

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

func (*CreateLaunchconfiguration) ExtractResult

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

func (*CreateLaunchconfiguration) ParamsHelp

func (cmd *CreateLaunchconfiguration) ParamsHelp() string

func (*CreateLaunchconfiguration) Run

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

func (*CreateLaunchconfiguration) SetApi

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

func (*CreateLaunchconfiguration) ValidateCommand

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

func (*CreateLaunchconfiguration) ValidateParams

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

type CreateListener

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

func NewCreateListener

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

func (*CreateListener) DryRun

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

func (*CreateListener) ExtractResult

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

func (*CreateListener) ParamsHelp

func (cmd *CreateListener) ParamsHelp() string

func (*CreateListener) Run

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

func (*CreateListener) SetApi

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

func (*CreateListener) ValidateCommand

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

func (*CreateListener) ValidateParams

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

type CreateLoadbalancer

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

func NewCreateLoadbalancer

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

func (*CreateLoadbalancer) DryRun

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

func (*CreateLoadbalancer) ExtractResult

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

func (*CreateLoadbalancer) ParamsHelp

func (cmd *CreateLoadbalancer) ParamsHelp() string

func (*CreateLoadbalancer) Run

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

func (*CreateLoadbalancer) SetApi

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

func (*CreateLoadbalancer) ValidateCommand

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

func (*CreateLoadbalancer) ValidateParams

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

type CreateLoginprofile

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

func NewCreateLoginprofile

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

func (*CreateLoginprofile) DryRun

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

func (*CreateLoginprofile) ExtractResult

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

func (*CreateLoginprofile) ParamsHelp

func (cmd *CreateLoginprofile) ParamsHelp() string

func (*CreateLoginprofile) Run

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

func (*CreateLoginprofile) SetApi

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

func (*CreateLoginprofile) ValidateCommand

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

func (*CreateLoginprofile) ValidateParams

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

type CreateMfadevice

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

func NewCreateMfadevice

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

func (*CreateMfadevice) DryRun

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

func (*CreateMfadevice) ExtractResult

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

func (*CreateMfadevice) ManualRun

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

func (*CreateMfadevice) ParamsHelp

func (cmd *CreateMfadevice) ParamsHelp() string

func (*CreateMfadevice) Run

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

func (*CreateMfadevice) SetApi

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

func (*CreateMfadevice) ValidateCommand

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

func (*CreateMfadevice) ValidateParams

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

type CreateNatgateway

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

func NewCreateNatgateway

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

func (*CreateNatgateway) DryRun

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

func (*CreateNatgateway) ExtractResult

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

func (*CreateNatgateway) ParamsHelp

func (cmd *CreateNatgateway) ParamsHelp() string

func (*CreateNatgateway) Run

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

func (*CreateNatgateway) SetApi

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

func (*CreateNatgateway) ValidateCommand

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

func (*CreateNatgateway) ValidateParams

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

type CreateNetworkinterface

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

func NewCreateNetworkinterface

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

func (*CreateNetworkinterface) DryRun

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

func (*CreateNetworkinterface) ExtractResult

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

func (*CreateNetworkinterface) ParamsHelp

func (cmd *CreateNetworkinterface) ParamsHelp() string

func (*CreateNetworkinterface) Run

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

func (*CreateNetworkinterface) SetApi

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

func (*CreateNetworkinterface) ValidateCommand

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

func (*CreateNetworkinterface) ValidateParams

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

type CreatePolicy

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

func NewCreatePolicy

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

func (*CreatePolicy) BeforeRun

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

func (*CreatePolicy) DryRun

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

func (*CreatePolicy) ExtractResult

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

func (*CreatePolicy) ParamsHelp

func (cmd *CreatePolicy) ParamsHelp() string

func (*CreatePolicy) Run

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

func (*CreatePolicy) SetApi

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

func (*CreatePolicy) ValidateCommand

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

func (*CreatePolicy) ValidateParams

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

type CreateQueue

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

func NewCreateQueue

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

func (*CreateQueue) DryRun

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

func (*CreateQueue) ExtractResult

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

func (*CreateQueue) ParamsHelp

func (cmd *CreateQueue) ParamsHelp() string

func (*CreateQueue) Run

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

func (*CreateQueue) SetApi

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

func (*CreateQueue) ValidateCommand

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

func (*CreateQueue) ValidateParams

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

type CreateRecord

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

func NewCreateRecord

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

func (*CreateRecord) DryRun

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

func (*CreateRecord) ExtractResult

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

func (*CreateRecord) ManualRun

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

func (*CreateRecord) ParamsHelp

func (cmd *CreateRecord) ParamsHelp() string

func (*CreateRecord) Run

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

func (*CreateRecord) SetApi

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

func (*CreateRecord) ValidateCommand

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

func (*CreateRecord) ValidateParams

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

type CreateRepository

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

func NewCreateRepository

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

func (*CreateRepository) DryRun

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

func (*CreateRepository) ExtractResult

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

func (*CreateRepository) ParamsHelp

func (cmd *CreateRepository) ParamsHelp() string

func (*CreateRepository) Run

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

func (*CreateRepository) SetApi

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

func (*CreateRepository) ValidateCommand

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

func (*CreateRepository) ValidateParams

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

type CreateRole

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

func NewCreateRole

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

func (*CreateRole) DryRun

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

func (*CreateRole) ExtractResult

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

func (*CreateRole) ManualRun

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

func (*CreateRole) ParamsHelp

func (cmd *CreateRole) ParamsHelp() string

func (*CreateRole) Run

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

func (*CreateRole) SetApi

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

func (*CreateRole) ValidateCommand

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

func (*CreateRole) ValidateParams

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

type CreateRoute

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

func NewCreateRoute

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

func (*CreateRoute) DryRun

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

func (*CreateRoute) ParamsHelp

func (cmd *CreateRoute) ParamsHelp() string

func (*CreateRoute) Run

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

func (*CreateRoute) SetApi

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

func (*CreateRoute) ValidateCommand

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

func (*CreateRoute) ValidateParams

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

func (*CreateRoute) Validate_CIDR

func (cmd *CreateRoute) Validate_CIDR() error

type CreateRoutetable

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

func NewCreateRoutetable

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

func (*CreateRoutetable) DryRun

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

func (*CreateRoutetable) ExtractResult

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

func (*CreateRoutetable) ParamsHelp

func (cmd *CreateRoutetable) ParamsHelp() string

func (*CreateRoutetable) Run

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

func (*CreateRoutetable) SetApi

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

func (*CreateRoutetable) ValidateCommand

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

func (*CreateRoutetable) ValidateParams

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

type CreateS3object

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

func NewCreateS3object

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

func (*CreateS3object) DryRun

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

func (*CreateS3object) ExtractResult

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

func (*CreateS3object) ManualRun

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

func (*CreateS3object) ParamsHelp

func (cmd *CreateS3object) ParamsHelp() string

func (*CreateS3object) Run

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

func (*CreateS3object) SetApi

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

func (*CreateS3object) ValidateCommand

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

func (*CreateS3object) ValidateParams

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

func (*CreateS3object) Validate_File

func (cmd *CreateS3object) Validate_File() error

type CreateScalinggroup

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

func NewCreateScalinggroup

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

func (*CreateScalinggroup) DryRun

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

func (*CreateScalinggroup) ExtractResult

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

func (*CreateScalinggroup) ParamsHelp

func (cmd *CreateScalinggroup) ParamsHelp() string

func (*CreateScalinggroup) Run

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

func (*CreateScalinggroup) SetApi

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

func (*CreateScalinggroup) ValidateCommand

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

func (*CreateScalinggroup) ValidateParams

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

type CreateScalingpolicy

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

func NewCreateScalingpolicy

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

func (*CreateScalingpolicy) DryRun

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

func (*CreateScalingpolicy) ExtractResult

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

func (*CreateScalingpolicy) ParamsHelp

func (cmd *CreateScalingpolicy) ParamsHelp() string

func (*CreateScalingpolicy) Run

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

func (*CreateScalingpolicy) SetApi

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

func (*CreateScalingpolicy) ValidateCommand

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

func (*CreateScalingpolicy) ValidateParams

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

type CreateSecuritygroup

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

func NewCreateSecuritygroup

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

func (*CreateSecuritygroup) DryRun

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

func (*CreateSecuritygroup) ExtractResult

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

func (*CreateSecuritygroup) ParamsHelp

func (cmd *CreateSecuritygroup) ParamsHelp() string

func (*CreateSecuritygroup) Run

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

func (*CreateSecuritygroup) SetApi

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

func (*CreateSecuritygroup) ValidateCommand

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

func (*CreateSecuritygroup) ValidateParams

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

type CreateSnapshot

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

func NewCreateSnapshot

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

func (*CreateSnapshot) DryRun

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

func (*CreateSnapshot) ExtractResult

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

func (*CreateSnapshot) ParamsHelp

func (cmd *CreateSnapshot) ParamsHelp() string

func (*CreateSnapshot) Run

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

func (*CreateSnapshot) SetApi

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

func (*CreateSnapshot) ValidateCommand

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

func (*CreateSnapshot) ValidateParams

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

type CreateStack

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

func NewCreateStack

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

func (*CreateStack) DryRun

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

func (*CreateStack) ExtractResult

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

func (*CreateStack) ParamsHelp

func (cmd *CreateStack) ParamsHelp() string

func (*CreateStack) Run

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

func (*CreateStack) SetApi

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

func (*CreateStack) ValidateCommand

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

func (*CreateStack) ValidateParams

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

func (*CreateStack) Validate_TemplateFile

func (cmd *CreateStack) Validate_TemplateFile() error

type CreateSubnet

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

func NewCreateSubnet

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

func (*CreateSubnet) AfterRun

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

func (*CreateSubnet) DryRun

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

func (*CreateSubnet) ExtractResult

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

func (*CreateSubnet) ParamsHelp

func (cmd *CreateSubnet) ParamsHelp() string

func (*CreateSubnet) Run

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

func (*CreateSubnet) SetApi

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

func (*CreateSubnet) ValidateCommand

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

func (*CreateSubnet) ValidateParams

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

func (*CreateSubnet) Validate_CIDR

func (cmd *CreateSubnet) Validate_CIDR() error

type CreateSubscription

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

func NewCreateSubscription

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

func (*CreateSubscription) DryRun

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

func (*CreateSubscription) ExtractResult

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

func (*CreateSubscription) ParamsHelp

func (cmd *CreateSubscription) ParamsHelp() string

func (*CreateSubscription) Run

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

func (*CreateSubscription) SetApi

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

func (*CreateSubscription) ValidateCommand

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

func (*CreateSubscription) ValidateParams

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

type CreateTag

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

func NewCreateTag

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

func (*CreateTag) DryRun

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

func (*CreateTag) ManualRun

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

func (*CreateTag) ParamsHelp

func (cmd *CreateTag) ParamsHelp() string

func (*CreateTag) Run

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

func (*CreateTag) SetApi

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

func (*CreateTag) ValidateCommand

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

func (*CreateTag) ValidateParams

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

type CreateTargetgroup

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

func NewCreateTargetgroup

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

func (*CreateTargetgroup) DryRun

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

func (*CreateTargetgroup) ExtractResult

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

func (*CreateTargetgroup) ParamsHelp

func (cmd *CreateTargetgroup) ParamsHelp() string

func (*CreateTargetgroup) Run

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

func (*CreateTargetgroup) SetApi

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

func (*CreateTargetgroup) ValidateCommand

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

func (*CreateTargetgroup) ValidateParams

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

type CreateTopic

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

func NewCreateTopic

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

func (*CreateTopic) DryRun

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

func (*CreateTopic) ExtractResult

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

func (*CreateTopic) ParamsHelp

func (cmd *CreateTopic) ParamsHelp() string

func (*CreateTopic) Run

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

func (*CreateTopic) SetApi

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

func (*CreateTopic) ValidateCommand

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

func (*CreateTopic) ValidateParams

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

type CreateUser

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

func NewCreateUser

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

func (*CreateUser) DryRun

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

func (*CreateUser) ExtractResult

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

func (*CreateUser) ParamsHelp

func (cmd *CreateUser) ParamsHelp() string

func (*CreateUser) Run

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

func (*CreateUser) SetApi

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

func (*CreateUser) ValidateCommand

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

func (*CreateUser) ValidateParams

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

type CreateVolume

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

func NewCreateVolume

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

func (*CreateVolume) DryRun

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

func (*CreateVolume) ExtractResult

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

func (*CreateVolume) ParamsHelp

func (cmd *CreateVolume) ParamsHelp() string

func (*CreateVolume) Run

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

func (*CreateVolume) SetApi

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

func (*CreateVolume) ValidateCommand

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

func (*CreateVolume) ValidateParams

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

type CreateVpc

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

func NewCreateVpc

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

func (*CreateVpc) AfterRun

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

func (*CreateVpc) DryRun

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

func (*CreateVpc) ExtractResult

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

func (*CreateVpc) ParamsHelp

func (cmd *CreateVpc) ParamsHelp() string

func (*CreateVpc) Run

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

func (*CreateVpc) SetApi

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

func (*CreateVpc) ValidateCommand

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

func (*CreateVpc) ValidateParams

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

func (*CreateVpc) Validate_CIDR

func (cmd *CreateVpc) Validate_CIDR() error

type CreateZone

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

func NewCreateZone

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

func (*CreateZone) DryRun

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

func (*CreateZone) ExtractResult

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

func (*CreateZone) ParamsHelp

func (cmd *CreateZone) ParamsHelp() string

func (*CreateZone) Run

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

func (*CreateZone) SetApi

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

func (*CreateZone) ValidateCommand

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

func (*CreateZone) ValidateParams

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

type Definition

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

func AWSLookupDefinitions

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

type DeleteAccesskey

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

func NewDeleteAccesskey

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

func (*DeleteAccesskey) DryRun

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

func (*DeleteAccesskey) ParamsHelp

func (cmd *DeleteAccesskey) ParamsHelp() string

func (*DeleteAccesskey) Run

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

func (*DeleteAccesskey) SetApi

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

func (*DeleteAccesskey) ValidateCommand

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

func (*DeleteAccesskey) ValidateParams

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

type DeleteAlarm

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

func NewDeleteAlarm

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

func (*DeleteAlarm) DryRun

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

func (*DeleteAlarm) ParamsHelp

func (cmd *DeleteAlarm) ParamsHelp() string

func (*DeleteAlarm) Run

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

func (*DeleteAlarm) SetApi

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

func (*DeleteAlarm) ValidateCommand

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

func (*DeleteAlarm) ValidateParams

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

type DeleteAppscalingpolicy

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

func NewDeleteAppscalingpolicy

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

func (*DeleteAppscalingpolicy) DryRun

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

func (*DeleteAppscalingpolicy) ParamsHelp

func (cmd *DeleteAppscalingpolicy) ParamsHelp() string

func (*DeleteAppscalingpolicy) Run

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

func (*DeleteAppscalingpolicy) SetApi

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

func (*DeleteAppscalingpolicy) ValidateCommand

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

func (*DeleteAppscalingpolicy) ValidateParams

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

type DeleteAppscalingtarget

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

func NewDeleteAppscalingtarget

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

func (*DeleteAppscalingtarget) DryRun

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

func (*DeleteAppscalingtarget) ParamsHelp

func (cmd *DeleteAppscalingtarget) ParamsHelp() string

func (*DeleteAppscalingtarget) Run

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

func (*DeleteAppscalingtarget) SetApi

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

func (*DeleteAppscalingtarget) ValidateCommand

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

func (*DeleteAppscalingtarget) ValidateParams

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

type DeleteBucket

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

func NewDeleteBucket

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

func (*DeleteBucket) DryRun

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

func (*DeleteBucket) ParamsHelp

func (cmd *DeleteBucket) ParamsHelp() string

func (*DeleteBucket) Run

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

func (*DeleteBucket) SetApi

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

func (*DeleteBucket) ValidateCommand

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

func (*DeleteBucket) ValidateParams

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

type DeleteCertificate

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

func NewDeleteCertificate

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

func (*DeleteCertificate) DryRun

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

func (*DeleteCertificate) ParamsHelp

func (cmd *DeleteCertificate) ParamsHelp() string

func (*DeleteCertificate) Run

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

func (*DeleteCertificate) SetApi

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

func (*DeleteCertificate) ValidateCommand

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

func (*DeleteCertificate) ValidateParams

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

type DeleteContainercluster

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

func NewDeleteContainercluster

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

func (*DeleteContainercluster) DryRun

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

func (*DeleteContainercluster) ParamsHelp

func (cmd *DeleteContainercluster) ParamsHelp() string

func (*DeleteContainercluster) Run

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

func (*DeleteContainercluster) SetApi

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

func (*DeleteContainercluster) ValidateCommand

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

func (*DeleteContainercluster) ValidateParams

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

type DeleteContainertask

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

func NewDeleteContainertask

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

func (*DeleteContainertask) DryRun

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

func (*DeleteContainertask) ManualRun

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

func (*DeleteContainertask) ParamsHelp

func (cmd *DeleteContainertask) ParamsHelp() string

func (*DeleteContainertask) Run

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

func (*DeleteContainertask) SetApi

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

func (*DeleteContainertask) ValidateCommand

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

func (*DeleteContainertask) ValidateParams

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

type DeleteDatabase

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

func NewDeleteDatabase

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

func (*DeleteDatabase) DryRun

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

func (*DeleteDatabase) ParamsHelp

func (cmd *DeleteDatabase) ParamsHelp() string

func (*DeleteDatabase) Run

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

func (*DeleteDatabase) SetApi

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

func (*DeleteDatabase) ValidateCommand

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

func (*DeleteDatabase) ValidateParams

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

type DeleteDbsubnetgroup

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

func NewDeleteDbsubnetgroup

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

func (*DeleteDbsubnetgroup) DryRun

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

func (*DeleteDbsubnetgroup) ParamsHelp

func (cmd *DeleteDbsubnetgroup) ParamsHelp() string

func (*DeleteDbsubnetgroup) Run

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

func (*DeleteDbsubnetgroup) SetApi

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

func (*DeleteDbsubnetgroup) ValidateCommand

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

func (*DeleteDbsubnetgroup) ValidateParams

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

type DeleteDistribution

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

func NewDeleteDistribution

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

func (*DeleteDistribution) DryRun

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

func (*DeleteDistribution) ManualRun

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

func (*DeleteDistribution) ParamsHelp

func (cmd *DeleteDistribution) ParamsHelp() string

func (*DeleteDistribution) Run

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

func (*DeleteDistribution) SetApi

func (cmd *DeleteDistribution) SetApi(api cloudfrontiface.CloudFrontAPI)

func (*DeleteDistribution) ValidateCommand

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

func (*DeleteDistribution) ValidateParams

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

type DeleteElasticip

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

func NewDeleteElasticip

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

func (*DeleteElasticip) DryRun

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

func (*DeleteElasticip) ParamsHelp

func (cmd *DeleteElasticip) ParamsHelp() string

func (*DeleteElasticip) Run

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

func (*DeleteElasticip) SetApi

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

func (*DeleteElasticip) ValidateCommand

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

func (*DeleteElasticip) ValidateParams

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

type DeleteFunction

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

func NewDeleteFunction

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

func (*DeleteFunction) DryRun

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

func (*DeleteFunction) ParamsHelp

func (cmd *DeleteFunction) ParamsHelp() string

func (*DeleteFunction) Run

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

func (*DeleteFunction) SetApi

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

func (*DeleteFunction) ValidateCommand

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

func (*DeleteFunction) ValidateParams

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

type DeleteGroup

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

func NewDeleteGroup

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

func (*DeleteGroup) DryRun

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

func (*DeleteGroup) ParamsHelp

func (cmd *DeleteGroup) ParamsHelp() string

func (*DeleteGroup) Run

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

func (*DeleteGroup) SetApi

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

func (*DeleteGroup) ValidateCommand

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

func (*DeleteGroup) ValidateParams

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

type DeleteImage

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

func NewDeleteImage

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

func (*DeleteImage) DryRun

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

func (*DeleteImage) ManualRun

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

func (*DeleteImage) ParamsHelp

func (cmd *DeleteImage) ParamsHelp() string

func (*DeleteImage) Run

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

func (*DeleteImage) SetApi

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

func (*DeleteImage) ValidateCommand

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

func (*DeleteImage) ValidateParams

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

type DeleteInstance

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

func NewDeleteInstance

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

func (*DeleteInstance) ConvertParams

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

func (*DeleteInstance) DryRun

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

func (*DeleteInstance) ParamsHelp

func (cmd *DeleteInstance) ParamsHelp() string

func (*DeleteInstance) Run

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

func (*DeleteInstance) SetApi

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

func (*DeleteInstance) ValidateCommand

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

func (*DeleteInstance) ValidateParams

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

type DeleteInstanceprofile

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

func NewDeleteInstanceprofile

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

func (*DeleteInstanceprofile) DryRun

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

func (*DeleteInstanceprofile) ParamsHelp

func (cmd *DeleteInstanceprofile) ParamsHelp() string

func (*DeleteInstanceprofile) Run

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

func (*DeleteInstanceprofile) SetApi

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

func (*DeleteInstanceprofile) ValidateCommand

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

func (*DeleteInstanceprofile) ValidateParams

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

type DeleteInternetgateway

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

func NewDeleteInternetgateway

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

func (*DeleteInternetgateway) DryRun

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

func (*DeleteInternetgateway) ParamsHelp

func (cmd *DeleteInternetgateway) ParamsHelp() string

func (*DeleteInternetgateway) Run

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

func (*DeleteInternetgateway) SetApi

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

func (*DeleteInternetgateway) ValidateCommand

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

func (*DeleteInternetgateway) ValidateParams

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

type DeleteKeypair

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

func NewDeleteKeypair

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

func (*DeleteKeypair) DryRun

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

func (*DeleteKeypair) ParamsHelp

func (cmd *DeleteKeypair) ParamsHelp() string

func (*DeleteKeypair) Run

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

func (*DeleteKeypair) SetApi

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

func (*DeleteKeypair) ValidateCommand

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

func (*DeleteKeypair) ValidateParams

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

type DeleteLaunchconfiguration

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

func NewDeleteLaunchconfiguration

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

func (*DeleteLaunchconfiguration) DryRun

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

func (*DeleteLaunchconfiguration) ParamsHelp

func (cmd *DeleteLaunchconfiguration) ParamsHelp() string

func (*DeleteLaunchconfiguration) Run

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

func (*DeleteLaunchconfiguration) SetApi

func (cmd *DeleteLaunchconfiguration) SetApi(api autoscalingiface.AutoScalingAPI)

func (*DeleteLaunchconfiguration) ValidateCommand

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

func (*DeleteLaunchconfiguration) ValidateParams

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

type DeleteListener

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

func NewDeleteListener

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

func (*DeleteListener) DryRun

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

func (*DeleteListener) ParamsHelp

func (cmd *DeleteListener) ParamsHelp() string

func (*DeleteListener) Run

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

func (*DeleteListener) SetApi

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

func (*DeleteListener) ValidateCommand

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

func (*DeleteListener) ValidateParams

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

type DeleteLoadbalancer

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

func NewDeleteLoadbalancer

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

func (*DeleteLoadbalancer) DryRun

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

func (*DeleteLoadbalancer) ParamsHelp

func (cmd *DeleteLoadbalancer) ParamsHelp() string

func (*DeleteLoadbalancer) Run

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

func (*DeleteLoadbalancer) SetApi

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

func (*DeleteLoadbalancer) ValidateCommand

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

func (*DeleteLoadbalancer) ValidateParams

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

type DeleteLoginprofile

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

func NewDeleteLoginprofile

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

func (*DeleteLoginprofile) DryRun

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

func (*DeleteLoginprofile) ParamsHelp

func (cmd *DeleteLoginprofile) ParamsHelp() string

func (*DeleteLoginprofile) Run

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

func (*DeleteLoginprofile) SetApi

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

func (*DeleteLoginprofile) ValidateCommand

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

func (*DeleteLoginprofile) ValidateParams

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

type DeleteMfadevice

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

func NewDeleteMfadevice

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

func (*DeleteMfadevice) DryRun

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

func (*DeleteMfadevice) ParamsHelp

func (cmd *DeleteMfadevice) ParamsHelp() string

func (*DeleteMfadevice) Run

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

func (*DeleteMfadevice) SetApi

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

func (*DeleteMfadevice) ValidateCommand

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

func (*DeleteMfadevice) ValidateParams

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

type DeleteNatgateway

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

func NewDeleteNatgateway

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

func (*DeleteNatgateway) DryRun

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

func (*DeleteNatgateway) ParamsHelp

func (cmd *DeleteNatgateway) ParamsHelp() string

func (*DeleteNatgateway) Run

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

func (*DeleteNatgateway) SetApi

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

func (*DeleteNatgateway) ValidateCommand

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

func (*DeleteNatgateway) ValidateParams

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

type DeleteNetworkinterface

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

func NewDeleteNetworkinterface

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

func (*DeleteNetworkinterface) DryRun

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

func (*DeleteNetworkinterface) ParamsHelp

func (cmd *DeleteNetworkinterface) ParamsHelp() string

func (*DeleteNetworkinterface) Run

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

func (*DeleteNetworkinterface) SetApi

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

func (*DeleteNetworkinterface) ValidateCommand

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

func (*DeleteNetworkinterface) ValidateParams

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

type DeletePolicy

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

func NewDeletePolicy

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

func (*DeletePolicy) BeforeRun

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

func (*DeletePolicy) DryRun

func (cmd *DeletePolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeletePolicy) ParamsHelp

func (cmd *DeletePolicy) ParamsHelp() string

func (*DeletePolicy) Run

func (cmd *DeletePolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeletePolicy) SetApi

func (cmd *DeletePolicy) SetApi(api iamiface.IAMAPI)

func (*DeletePolicy) ValidateCommand

func (cmd *DeletePolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeletePolicy) ValidateParams

func (cmd *DeletePolicy) ValidateParams(params []string) ([]string, error)

type DeleteQueue

type DeleteQueue struct {
	Url *string `awsName:"QueueUrl" awsType:"awsstr" templateName:"url" required:""`
	// contains filtered or unexported fields
}

func NewDeleteQueue

func NewDeleteQueue(sess *session.Session, l ...*logger.Logger) *DeleteQueue

func (*DeleteQueue) DryRun

func (cmd *DeleteQueue) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteQueue) ParamsHelp

func (cmd *DeleteQueue) ParamsHelp() string

func (*DeleteQueue) Run

func (cmd *DeleteQueue) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteQueue) SetApi

func (cmd *DeleteQueue) SetApi(api sqsiface.SQSAPI)

func (*DeleteQueue) ValidateCommand

func (cmd *DeleteQueue) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteQueue) ValidateParams

func (cmd *DeleteQueue) ValidateParams(params []string) ([]string, error)

type DeleteRecord

type DeleteRecord struct {
	Zone  *string `templateName:"zone" required:""`
	Name  *string `templateName:"name" required:""`
	Type  *string `templateName:"type" required:""`
	Value *string `templateName:"value" required:""`
	Ttl   *int64  `templateName:"ttl" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRecord

func NewDeleteRecord(sess *session.Session, l ...*logger.Logger) *DeleteRecord

func (*DeleteRecord) DryRun

func (cmd *DeleteRecord) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRecord) ExtractResult

func (cmd *DeleteRecord) ExtractResult(i interface{}) string

func (*DeleteRecord) ManualRun

func (cmd *DeleteRecord) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteRecord) ParamsHelp

func (cmd *DeleteRecord) ParamsHelp() string

func (*DeleteRecord) Run

func (cmd *DeleteRecord) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRecord) SetApi

func (cmd *DeleteRecord) SetApi(api route53iface.Route53API)

func (*DeleteRecord) ValidateCommand

func (cmd *DeleteRecord) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRecord) ValidateParams

func (cmd *DeleteRecord) ValidateParams(params []string) ([]string, error)

type DeleteRepository

type DeleteRepository struct {
	Name    *string `awsName:"RepositoryName" awsType:"awsstr" templateName:"name" required:""`
	Force   *bool   `awsName:"Force" awsType:"awsbool" templateName:"force"`
	Account *string `awsName:"RegistryId" awsType:"awsstr" templateName:"account"`
	// contains filtered or unexported fields
}

func NewDeleteRepository

func NewDeleteRepository(sess *session.Session, l ...*logger.Logger) *DeleteRepository

func (*DeleteRepository) DryRun

func (cmd *DeleteRepository) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRepository) ParamsHelp

func (cmd *DeleteRepository) ParamsHelp() string

func (*DeleteRepository) Run

func (cmd *DeleteRepository) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRepository) SetApi

func (cmd *DeleteRepository) SetApi(api ecriface.ECRAPI)

func (*DeleteRepository) ValidateCommand

func (cmd *DeleteRepository) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRepository) ValidateParams

func (cmd *DeleteRepository) ValidateParams(params []string) ([]string, error)

type DeleteRole

type DeleteRole struct {
	Name *string `awsName:"RoleName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRole

func NewDeleteRole(sess *session.Session, l ...*logger.Logger) *DeleteRole

func (*DeleteRole) DryRun

func (cmd *DeleteRole) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRole) ManualRun

func (cmd *DeleteRole) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteRole) ParamsHelp

func (cmd *DeleteRole) ParamsHelp() string

func (*DeleteRole) Run

func (cmd *DeleteRole) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRole) SetApi

func (cmd *DeleteRole) SetApi(api iamiface.IAMAPI)

func (*DeleteRole) ValidateCommand

func (cmd *DeleteRole) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRole) ValidateParams

func (cmd *DeleteRole) ValidateParams(params []string) ([]string, error)

type DeleteRoute

type DeleteRoute struct {
	Table *string `awsName:"RouteTableId" awsType:"awsstr" templateName:"table" required:""`
	CIDR  *string `awsName:"DestinationCidrBlock" awsType:"awsstr" templateName:"cidr" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRoute

func NewDeleteRoute(sess *session.Session, l ...*logger.Logger) *DeleteRoute

func (*DeleteRoute) DryRun

func (cmd *DeleteRoute) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoute) ParamsHelp

func (cmd *DeleteRoute) ParamsHelp() string

func (*DeleteRoute) Run

func (cmd *DeleteRoute) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoute) SetApi

func (cmd *DeleteRoute) SetApi(api ec2iface.EC2API)

func (*DeleteRoute) ValidateCommand

func (cmd *DeleteRoute) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRoute) ValidateParams

func (cmd *DeleteRoute) ValidateParams(params []string) ([]string, error)

func (*DeleteRoute) Validate_CIDR

func (cmd *DeleteRoute) Validate_CIDR() error

type DeleteRoutetable

type DeleteRoutetable struct {
	Id *string `awsName:"RouteTableId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteRoutetable

func NewDeleteRoutetable(sess *session.Session, l ...*logger.Logger) *DeleteRoutetable

func (*DeleteRoutetable) DryRun

func (cmd *DeleteRoutetable) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoutetable) ParamsHelp

func (cmd *DeleteRoutetable) ParamsHelp() string

func (*DeleteRoutetable) Run

func (cmd *DeleteRoutetable) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteRoutetable) SetApi

func (cmd *DeleteRoutetable) SetApi(api ec2iface.EC2API)

func (*DeleteRoutetable) ValidateCommand

func (cmd *DeleteRoutetable) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteRoutetable) ValidateParams

func (cmd *DeleteRoutetable) ValidateParams(params []string) ([]string, error)

type DeleteS3object

type DeleteS3object struct {
	Bucket *string `awsName:"Bucket" awsType:"awsstr" templateName:"bucket" required:""`
	Name   *string `awsName:"Key" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteS3object

func NewDeleteS3object(sess *session.Session, l ...*logger.Logger) *DeleteS3object

func (*DeleteS3object) DryRun

func (cmd *DeleteS3object) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteS3object) ParamsHelp

func (cmd *DeleteS3object) ParamsHelp() string

func (*DeleteS3object) Run

func (cmd *DeleteS3object) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteS3object) SetApi

func (cmd *DeleteS3object) SetApi(api s3iface.S3API)

func (*DeleteS3object) ValidateCommand

func (cmd *DeleteS3object) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteS3object) ValidateParams

func (cmd *DeleteS3object) ValidateParams(params []string) ([]string, error)

type DeleteScalinggroup

type DeleteScalinggroup struct {
	Name  *string `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name" required:""`
	Force *bool   `awsName:"ForceDelete" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDeleteScalinggroup

func NewDeleteScalinggroup(sess *session.Session, l ...*logger.Logger) *DeleteScalinggroup

func (*DeleteScalinggroup) DryRun

func (cmd *DeleteScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalinggroup) ParamsHelp

func (cmd *DeleteScalinggroup) ParamsHelp() string

func (*DeleteScalinggroup) Run

func (cmd *DeleteScalinggroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalinggroup) SetApi

func (cmd *DeleteScalinggroup) SetApi(api autoscalingiface.AutoScalingAPI)

func (*DeleteScalinggroup) ValidateCommand

func (cmd *DeleteScalinggroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteScalinggroup) ValidateParams

func (cmd *DeleteScalinggroup) ValidateParams(params []string) ([]string, error)

type DeleteScalingpolicy

type DeleteScalingpolicy struct {
	Id *string `awsName:"PolicyName" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteScalingpolicy

func NewDeleteScalingpolicy(sess *session.Session, l ...*logger.Logger) *DeleteScalingpolicy

func (*DeleteScalingpolicy) DryRun

func (cmd *DeleteScalingpolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalingpolicy) ParamsHelp

func (cmd *DeleteScalingpolicy) ParamsHelp() string

func (*DeleteScalingpolicy) Run

func (cmd *DeleteScalingpolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteScalingpolicy) SetApi

func (cmd *DeleteScalingpolicy) SetApi(api autoscalingiface.AutoScalingAPI)

func (*DeleteScalingpolicy) ValidateCommand

func (cmd *DeleteScalingpolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteScalingpolicy) ValidateParams

func (cmd *DeleteScalingpolicy) ValidateParams(params []string) ([]string, error)

type DeleteSecuritygroup

type DeleteSecuritygroup struct {
	Id *string `awsName:"GroupId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSecuritygroup

func NewDeleteSecuritygroup(sess *session.Session, l ...*logger.Logger) *DeleteSecuritygroup

func (*DeleteSecuritygroup) DryRun

func (cmd *DeleteSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSecuritygroup) ParamsHelp

func (cmd *DeleteSecuritygroup) ParamsHelp() string

func (*DeleteSecuritygroup) Run

func (cmd *DeleteSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSecuritygroup) SetApi

func (cmd *DeleteSecuritygroup) SetApi(api ec2iface.EC2API)

func (*DeleteSecuritygroup) ValidateCommand

func (cmd *DeleteSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSecuritygroup) ValidateParams

func (cmd *DeleteSecuritygroup) ValidateParams(params []string) ([]string, error)

type DeleteSnapshot

type DeleteSnapshot struct {
	Id *string `awsName:"SnapshotId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSnapshot

func NewDeleteSnapshot(sess *session.Session, l ...*logger.Logger) *DeleteSnapshot

func (*DeleteSnapshot) DryRun

func (cmd *DeleteSnapshot) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSnapshot) ParamsHelp

func (cmd *DeleteSnapshot) ParamsHelp() string

func (*DeleteSnapshot) Run

func (cmd *DeleteSnapshot) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSnapshot) SetApi

func (cmd *DeleteSnapshot) SetApi(api ec2iface.EC2API)

func (*DeleteSnapshot) ValidateCommand

func (cmd *DeleteSnapshot) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSnapshot) ValidateParams

func (cmd *DeleteSnapshot) ValidateParams(params []string) ([]string, error)

type DeleteStack

type DeleteStack struct {
	Name            *string   `awsName:"StackName" awsType:"awsstr" templateName:"name" required:""`
	RetainResources []*string `awsName:"RetainResources" awsType:"awsstringslice" templateName:"retain-resources"`
	// contains filtered or unexported fields
}

func NewDeleteStack

func NewDeleteStack(sess *session.Session, l ...*logger.Logger) *DeleteStack

func (*DeleteStack) DryRun

func (cmd *DeleteStack) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteStack) ParamsHelp

func (cmd *DeleteStack) ParamsHelp() string

func (*DeleteStack) Run

func (cmd *DeleteStack) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteStack) SetApi

func (cmd *DeleteStack) SetApi(api cloudformationiface.CloudFormationAPI)

func (*DeleteStack) ValidateCommand

func (cmd *DeleteStack) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteStack) ValidateParams

func (cmd *DeleteStack) ValidateParams(params []string) ([]string, error)

type DeleteSubnet

type DeleteSubnet struct {
	Id *string `awsName:"SubnetId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSubnet

func NewDeleteSubnet(sess *session.Session, l ...*logger.Logger) *DeleteSubnet

func (*DeleteSubnet) DryRun

func (cmd *DeleteSubnet) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubnet) ParamsHelp

func (cmd *DeleteSubnet) ParamsHelp() string

func (*DeleteSubnet) Run

func (cmd *DeleteSubnet) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubnet) SetApi

func (cmd *DeleteSubnet) SetApi(api ec2iface.EC2API)

func (*DeleteSubnet) ValidateCommand

func (cmd *DeleteSubnet) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSubnet) ValidateParams

func (cmd *DeleteSubnet) ValidateParams(params []string) ([]string, error)

type DeleteSubscription

type DeleteSubscription struct {
	Id *string `awsName:"SubscriptionArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteSubscription

func NewDeleteSubscription(sess *session.Session, l ...*logger.Logger) *DeleteSubscription

func (*DeleteSubscription) DryRun

func (cmd *DeleteSubscription) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubscription) ParamsHelp

func (cmd *DeleteSubscription) ParamsHelp() string

func (*DeleteSubscription) Run

func (cmd *DeleteSubscription) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteSubscription) SetApi

func (cmd *DeleteSubscription) SetApi(api snsiface.SNSAPI)

func (*DeleteSubscription) ValidateCommand

func (cmd *DeleteSubscription) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteSubscription) ValidateParams

func (cmd *DeleteSubscription) ValidateParams(params []string) ([]string, error)

type DeleteTag

type DeleteTag struct {
	Resource *string `awsName:"Resources" awsType:"awsstringslice" templateName:"resource" required:""`
	Key      *string `templateName:"key" required:""`
	Value    *string `templateName:"value"`
	// contains filtered or unexported fields
}

func NewDeleteTag

func NewDeleteTag(sess *session.Session, l ...*logger.Logger) *DeleteTag

func (*DeleteTag) DryRun

func (cmd *DeleteTag) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTag) ManualRun

func (cmd *DeleteTag) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DeleteTag) ParamsHelp

func (cmd *DeleteTag) ParamsHelp() string

func (*DeleteTag) Run

func (cmd *DeleteTag) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTag) SetApi

func (cmd *DeleteTag) SetApi(api ec2iface.EC2API)

func (*DeleteTag) ValidateCommand

func (cmd *DeleteTag) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteTag) ValidateParams

func (cmd *DeleteTag) ValidateParams(params []string) ([]string, error)

type DeleteTargetgroup

type DeleteTargetgroup struct {
	Id *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteTargetgroup

func NewDeleteTargetgroup(sess *session.Session, l ...*logger.Logger) *DeleteTargetgroup

func (*DeleteTargetgroup) DryRun

func (cmd *DeleteTargetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTargetgroup) ParamsHelp

func (cmd *DeleteTargetgroup) ParamsHelp() string

func (*DeleteTargetgroup) Run

func (cmd *DeleteTargetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTargetgroup) SetApi

func (cmd *DeleteTargetgroup) SetApi(api elbv2iface.ELBV2API)

func (*DeleteTargetgroup) ValidateCommand

func (cmd *DeleteTargetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteTargetgroup) ValidateParams

func (cmd *DeleteTargetgroup) ValidateParams(params []string) ([]string, error)

type DeleteTopic

type DeleteTopic struct {
	Id *string `awsName:"TopicArn" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteTopic

func NewDeleteTopic(sess *session.Session, l ...*logger.Logger) *DeleteTopic

func (*DeleteTopic) DryRun

func (cmd *DeleteTopic) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTopic) ParamsHelp

func (cmd *DeleteTopic) ParamsHelp() string

func (*DeleteTopic) Run

func (cmd *DeleteTopic) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteTopic) SetApi

func (cmd *DeleteTopic) SetApi(api snsiface.SNSAPI)

func (*DeleteTopic) ValidateCommand

func (cmd *DeleteTopic) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteTopic) ValidateParams

func (cmd *DeleteTopic) ValidateParams(params []string) ([]string, error)

type DeleteUser

type DeleteUser struct {
	Name *string `awsName:"UserName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDeleteUser

func NewDeleteUser(sess *session.Session, l ...*logger.Logger) *DeleteUser

func (*DeleteUser) DryRun

func (cmd *DeleteUser) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteUser) ParamsHelp

func (cmd *DeleteUser) ParamsHelp() string

func (*DeleteUser) Run

func (cmd *DeleteUser) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteUser) SetApi

func (cmd *DeleteUser) SetApi(api iamiface.IAMAPI)

func (*DeleteUser) ValidateCommand

func (cmd *DeleteUser) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteUser) ValidateParams

func (cmd *DeleteUser) ValidateParams(params []string) ([]string, error)

type DeleteVolume

type DeleteVolume struct {
	Id *string `awsName:"VolumeId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteVolume

func NewDeleteVolume(sess *session.Session, l ...*logger.Logger) *DeleteVolume

func (*DeleteVolume) DryRun

func (cmd *DeleteVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVolume) ParamsHelp

func (cmd *DeleteVolume) ParamsHelp() string

func (*DeleteVolume) Run

func (cmd *DeleteVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVolume) SetApi

func (cmd *DeleteVolume) SetApi(api ec2iface.EC2API)

func (*DeleteVolume) ValidateCommand

func (cmd *DeleteVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteVolume) ValidateParams

func (cmd *DeleteVolume) ValidateParams(params []string) ([]string, error)

type DeleteVpc

type DeleteVpc struct {
	Id *string `awsName:"VpcId" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteVpc

func NewDeleteVpc(sess *session.Session, l ...*logger.Logger) *DeleteVpc

func (*DeleteVpc) DryRun

func (cmd *DeleteVpc) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVpc) ParamsHelp

func (cmd *DeleteVpc) ParamsHelp() string

func (*DeleteVpc) Run

func (cmd *DeleteVpc) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteVpc) SetApi

func (cmd *DeleteVpc) SetApi(api ec2iface.EC2API)

func (*DeleteVpc) ValidateCommand

func (cmd *DeleteVpc) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteVpc) ValidateParams

func (cmd *DeleteVpc) ValidateParams(params []string) ([]string, error)

type DeleteZone

type DeleteZone struct {
	Id *string `awsName:"Id" awsType:"awsstr" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDeleteZone

func NewDeleteZone(sess *session.Session, l ...*logger.Logger) *DeleteZone

func (*DeleteZone) DryRun

func (cmd *DeleteZone) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteZone) ParamsHelp

func (cmd *DeleteZone) ParamsHelp() string

func (*DeleteZone) Run

func (cmd *DeleteZone) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DeleteZone) SetApi

func (cmd *DeleteZone) SetApi(api route53iface.Route53API)

func (*DeleteZone) ValidateCommand

func (cmd *DeleteZone) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DeleteZone) ValidateParams

func (cmd *DeleteZone) ValidateParams(params []string) ([]string, error)

type DetachAlarm

type DetachAlarm struct {
	Name      *string `templateName:"name" required:""`
	ActionArn *string `templateName:"action-arn" required:""`
	// contains filtered or unexported fields
}

func NewDetachAlarm

func NewDetachAlarm(sess *session.Session, l ...*logger.Logger) *DetachAlarm

func (*DetachAlarm) DryRun

func (cmd *DetachAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachAlarm) ManualRun

func (cmd *DetachAlarm) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachAlarm) ParamsHelp

func (cmd *DetachAlarm) ParamsHelp() string

func (*DetachAlarm) Run

func (cmd *DetachAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachAlarm) SetApi

func (cmd *DetachAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*DetachAlarm) ValidateCommand

func (cmd *DetachAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachAlarm) ValidateParams

func (cmd *DetachAlarm) ValidateParams(params []string) ([]string, error)

type DetachContainertask

type DetachContainertask struct {
	Name          *string `templateName:"name" required:""`
	ContainerName *string `templateName:"container-name" required:""`
	// contains filtered or unexported fields
}

func NewDetachContainertask

func NewDetachContainertask(sess *session.Session, l ...*logger.Logger) *DetachContainertask

func (*DetachContainertask) DryRun

func (cmd *DetachContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachContainertask) ManualRun

func (cmd *DetachContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachContainertask) ParamsHelp

func (cmd *DetachContainertask) ParamsHelp() string

func (*DetachContainertask) Run

func (cmd *DetachContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachContainertask) SetApi

func (cmd *DetachContainertask) SetApi(api ecsiface.ECSAPI)

func (*DetachContainertask) ValidateCommand

func (cmd *DetachContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachContainertask) ValidateParams

func (cmd *DetachContainertask) ValidateParams(params []string) ([]string, error)

type DetachElasticip

type DetachElasticip struct {
	Association *string `awsName:"AssociationId" awsType:"awsstr" templateName:"association" required:""`
	// contains filtered or unexported fields
}

func NewDetachElasticip

func NewDetachElasticip(sess *session.Session, l ...*logger.Logger) *DetachElasticip

func (*DetachElasticip) DryRun

func (cmd *DetachElasticip) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachElasticip) ParamsHelp

func (cmd *DetachElasticip) ParamsHelp() string

func (*DetachElasticip) Run

func (cmd *DetachElasticip) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachElasticip) SetApi

func (cmd *DetachElasticip) SetApi(api ec2iface.EC2API)

func (*DetachElasticip) ValidateCommand

func (cmd *DetachElasticip) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachElasticip) ValidateParams

func (cmd *DetachElasticip) ValidateParams(params []string) ([]string, error)

type DetachInstance

type DetachInstance struct {
	Targetgroup *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"targetgroup" required:""`
	Id          *string `awsName:"Targets[0]Id" awsType:"awsslicestruct" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewDetachInstance

func NewDetachInstance(sess *session.Session, l ...*logger.Logger) *DetachInstance

func (*DetachInstance) DryRun

func (cmd *DetachInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstance) ParamsHelp

func (cmd *DetachInstance) ParamsHelp() string

func (*DetachInstance) Run

func (cmd *DetachInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstance) SetApi

func (cmd *DetachInstance) SetApi(api elbv2iface.ELBV2API)

func (*DetachInstance) ValidateCommand

func (cmd *DetachInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachInstance) ValidateParams

func (cmd *DetachInstance) ValidateParams(params []string) ([]string, error)

type DetachInstanceprofile

type DetachInstanceprofile struct {
	Instance *string `templateName:"instance" required:""`
	Name     *string `templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDetachInstanceprofile

func NewDetachInstanceprofile(sess *session.Session, l ...*logger.Logger) *DetachInstanceprofile

func (*DetachInstanceprofile) DryRun

func (cmd *DetachInstanceprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstanceprofile) ExtractResult

func (cmd *DetachInstanceprofile) ExtractResult(i interface{}) string

func (*DetachInstanceprofile) ManualRun

func (cmd *DetachInstanceprofile) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachInstanceprofile) ParamsHelp

func (cmd *DetachInstanceprofile) ParamsHelp() string

func (*DetachInstanceprofile) Run

func (cmd *DetachInstanceprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInstanceprofile) SetApi

func (cmd *DetachInstanceprofile) SetApi(api ec2iface.EC2API)

func (*DetachInstanceprofile) ValidateCommand

func (cmd *DetachInstanceprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachInstanceprofile) ValidateParams

func (cmd *DetachInstanceprofile) ValidateParams(params []string) ([]string, error)

type DetachInternetgateway

type DetachInternetgateway struct {
	Id  *string `awsName:"InternetGatewayId" awsType:"awsstr" templateName:"id" required:""`
	Vpc *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc" required:""`
	// contains filtered or unexported fields
}

func NewDetachInternetgateway

func NewDetachInternetgateway(sess *session.Session, l ...*logger.Logger) *DetachInternetgateway

func (*DetachInternetgateway) DryRun

func (cmd *DetachInternetgateway) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInternetgateway) ParamsHelp

func (cmd *DetachInternetgateway) ParamsHelp() string

func (*DetachInternetgateway) Run

func (cmd *DetachInternetgateway) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachInternetgateway) SetApi

func (cmd *DetachInternetgateway) SetApi(api ec2iface.EC2API)

func (*DetachInternetgateway) ValidateCommand

func (cmd *DetachInternetgateway) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachInternetgateway) ValidateParams

func (cmd *DetachInternetgateway) ValidateParams(params []string) ([]string, error)

type DetachMfadevice

type DetachMfadevice struct {
	Id   *string `awsName:"SerialNumber" awsType:"awsstr" templateName:"id" required:""`
	User *string `awsName:"UserName" awsType:"awsstr" templateName:"user" required:""`
	// contains filtered or unexported fields
}

func NewDetachMfadevice

func NewDetachMfadevice(sess *session.Session, l ...*logger.Logger) *DetachMfadevice

func (*DetachMfadevice) DryRun

func (cmd *DetachMfadevice) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachMfadevice) ParamsHelp

func (cmd *DetachMfadevice) ParamsHelp() string

func (*DetachMfadevice) Run

func (cmd *DetachMfadevice) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachMfadevice) SetApi

func (cmd *DetachMfadevice) SetApi(api iamiface.IAMAPI)

func (*DetachMfadevice) ValidateCommand

func (cmd *DetachMfadevice) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachMfadevice) ValidateParams

func (cmd *DetachMfadevice) ValidateParams(params []string) ([]string, error)

type DetachNetworkinterface

type DetachNetworkinterface struct {
	Attachment *string `awsName:"AttachmentId" awsType:"awsstr" templateName:"attachment"`
	Instance   *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance"`
	Id         *string `awsName:"NetworkInterfaceId" awsType:"awsstr" templateName:"id"`
	Force      *bool   `awsName:"Force" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDetachNetworkinterface

func NewDetachNetworkinterface(sess *session.Session, l ...*logger.Logger) *DetachNetworkinterface

func (*DetachNetworkinterface) DryRun

func (cmd *DetachNetworkinterface) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachNetworkinterface) ManualRun

func (cmd *DetachNetworkinterface) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachNetworkinterface) ParamsHelp

func (cmd *DetachNetworkinterface) ParamsHelp() string

func (*DetachNetworkinterface) Run

func (cmd *DetachNetworkinterface) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachNetworkinterface) SetApi

func (cmd *DetachNetworkinterface) SetApi(api ec2iface.EC2API)

func (*DetachNetworkinterface) ValidateCommand

func (cmd *DetachNetworkinterface) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachNetworkinterface) ValidateParams

func (cmd *DetachNetworkinterface) ValidateParams(params []string) ([]string, error)

type DetachPolicy

type DetachPolicy struct {
	Arn   *string `awsName:"PolicyArn" awsType:"awsstr" templateName:"arn"`
	User  *string `awsName:"UserName" awsType:"awsstr" templateName:"user"`
	Group *string `awsName:"GroupName" awsType:"awsstr" templateName:"group"`
	Role  *string `awsName:"RoleName" awsType:"awsstr" templateName:"role"`
	// contains filtered or unexported fields
}

func NewDetachPolicy

func NewDetachPolicy(sess *session.Session, l ...*logger.Logger) *DetachPolicy

func (*DetachPolicy) ConvertParams

func (cmd *DetachPolicy) ConvertParams() ([]string, func(values map[string]interface{}) (map[string]interface{}, error))

func (*DetachPolicy) DryRun

func (cmd *DetachPolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachPolicy) ManualRun

func (cmd *DetachPolicy) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachPolicy) ParamsHelp

func (cmd *DetachPolicy) ParamsHelp() string

func (*DetachPolicy) Run

func (cmd *DetachPolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachPolicy) SetApi

func (cmd *DetachPolicy) SetApi(api iamiface.IAMAPI)

func (*DetachPolicy) ValidateCommand

func (cmd *DetachPolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachPolicy) ValidateParams

func (cmd *DetachPolicy) ValidateParams(params []string) ([]string, error)

type DetachRole

type DetachRole struct {
	Instanceprofile *string `awsName:"InstanceProfileName" awsType:"awsstr" templateName:"instanceprofile" required:""`
	Name            *string `awsName:"RoleName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDetachRole

func NewDetachRole(sess *session.Session, l ...*logger.Logger) *DetachRole

func (*DetachRole) DryRun

func (cmd *DetachRole) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRole) ParamsHelp

func (cmd *DetachRole) ParamsHelp() string

func (*DetachRole) Run

func (cmd *DetachRole) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRole) SetApi

func (cmd *DetachRole) SetApi(api iamiface.IAMAPI)

func (*DetachRole) ValidateCommand

func (cmd *DetachRole) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachRole) ValidateParams

func (cmd *DetachRole) ValidateParams(params []string) ([]string, error)

type DetachRoutetable

type DetachRoutetable struct {
	Association *string `awsName:"AssociationId" awsType:"awsstr" templateName:"association" required:""`
	// contains filtered or unexported fields
}

func NewDetachRoutetable

func NewDetachRoutetable(sess *session.Session, l ...*logger.Logger) *DetachRoutetable

func (*DetachRoutetable) DryRun

func (cmd *DetachRoutetable) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRoutetable) ParamsHelp

func (cmd *DetachRoutetable) ParamsHelp() string

func (*DetachRoutetable) Run

func (cmd *DetachRoutetable) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachRoutetable) SetApi

func (cmd *DetachRoutetable) SetApi(api ec2iface.EC2API)

func (*DetachRoutetable) ValidateCommand

func (cmd *DetachRoutetable) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachRoutetable) ValidateParams

func (cmd *DetachRoutetable) ValidateParams(params []string) ([]string, error)

type DetachSecuritygroup

type DetachSecuritygroup struct {
	Id       *string `templateName:"id" required:""`
	Instance *string `templateName:"instance" required:""`
	// contains filtered or unexported fields
}

func NewDetachSecuritygroup

func NewDetachSecuritygroup(sess *session.Session, l ...*logger.Logger) *DetachSecuritygroup

func (*DetachSecuritygroup) DryRun

func (cmd *DetachSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachSecuritygroup) ManualRun

func (cmd *DetachSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*DetachSecuritygroup) ParamsHelp

func (cmd *DetachSecuritygroup) ParamsHelp() string

func (*DetachSecuritygroup) Run

func (cmd *DetachSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachSecuritygroup) SetApi

func (cmd *DetachSecuritygroup) SetApi(api ec2iface.EC2API)

func (*DetachSecuritygroup) ValidateCommand

func (cmd *DetachSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachSecuritygroup) ValidateParams

func (cmd *DetachSecuritygroup) ValidateParams(params []string) ([]string, error)

type DetachUser

type DetachUser struct {
	Group *string `awsName:"GroupName" awsType:"awsstr" templateName:"group" required:""`
	Name  *string `awsName:"UserName" awsType:"awsstr" templateName:"name" required:""`
	// contains filtered or unexported fields
}

func NewDetachUser

func NewDetachUser(sess *session.Session, l ...*logger.Logger) *DetachUser

func (*DetachUser) DryRun

func (cmd *DetachUser) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachUser) ParamsHelp

func (cmd *DetachUser) ParamsHelp() string

func (*DetachUser) Run

func (cmd *DetachUser) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachUser) SetApi

func (cmd *DetachUser) SetApi(api iamiface.IAMAPI)

func (*DetachUser) ValidateCommand

func (cmd *DetachUser) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachUser) ValidateParams

func (cmd *DetachUser) ValidateParams(params []string) ([]string, error)

type DetachVolume

type DetachVolume struct {
	Device   *string `awsName:"Device" awsType:"awsstr" templateName:"device" required:""`
	Id       *string `awsName:"VolumeId" awsType:"awsstr" templateName:"id" required:""`
	Instance *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance" required:""`
	Force    *bool   `awsName:"Force" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDetachVolume

func NewDetachVolume(sess *session.Session, l ...*logger.Logger) *DetachVolume

func (*DetachVolume) DryRun

func (cmd *DetachVolume) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachVolume) ExtractResult

func (cmd *DetachVolume) ExtractResult(i interface{}) string

func (*DetachVolume) ParamsHelp

func (cmd *DetachVolume) ParamsHelp() string

func (*DetachVolume) Run

func (cmd *DetachVolume) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*DetachVolume) SetApi

func (cmd *DetachVolume) SetApi(api ec2iface.EC2API)

func (*DetachVolume) ValidateCommand

func (cmd *DetachVolume) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*DetachVolume) ValidateParams

func (cmd *DetachVolume) ValidateParams(params []string) ([]string, error)

type Distro

type Distro struct {
	Name, Variant, Arch, Virt, Store string
}

type Factory

type Factory interface {
	Build(key string) func() interface{}
}

var CommandFactory Factory

type ImageQuery

type ImageQuery struct {
	Platform Platform
	Distro   Distro
}

func ParseImageQuery

func ParseImageQuery(s string) (ImageQuery, error)

func (ImageQuery) String

func (q ImageQuery) String() string

type ImageResolver

type ImageResolver func(*ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error)

Image resolving allows to find AWS AMIs identifiers specifying what you want instead of an id that is specific to a region. The ami query string specification is as follows:

owner:distro:variant:arch:virtualization:store

Everything optional expect for the owner.

As for now only the main specific owner are taken into account and we deal with bares machines only distribution. Here are some examples:

- canonical:ubuntu:trusty

- redhat:rhel:6.8

- redhat::6.8

- amazonlinux

- suselinux:sles-12

- canonical:::i386

- redhat::::instance-store

The default values are: Arch="x86_64", Virt="hvm", Store="ebs"

func EC2ImageResolver

func EC2ImageResolver() ImageResolver

func (ImageResolver) Resolve

func (resolv ImageResolver) Resolve(q ImageQuery) ([]*AwsImage, bool, error)

type ImageResolverCache

type ImageResolverCache struct {
	// contains filtered or unexported fields
}

func (*ImageResolverCache) Get

func (r *ImageResolverCache) Get(key string) ([]*AwsImage, bool)

func (*ImageResolverCache) Store

func (r *ImageResolverCache) Store(key string, images []*AwsImage)

type ImportImage

type ImportImage struct {
	Architecture *string `awsName:"Architecture" awsType:"awsstr" templateName:"architecture"`
	Description  *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	License      *string `awsName:"LicenseType" awsType:"awsstr" templateName:"license"`
	Platform     *string `awsName:"Platform" awsType:"awsstr" templateName:"platform"`
	Role         *string `awsName:"RoleName" awsType:"awsstr" templateName:"role"`
	Snapshot     *string `awsName:"DiskContainers[0]SnapshotId" awsType:"awsslicestruct" templateName:"snapshot"`
	Url          *string `awsName:"DiskContainers[0]Url" awsType:"awsslicestruct" templateName:"url"`
	Bucket       *string `awsName:"DiskContainers[0]UserBucket.S3Bucket" awsType:"awsslicestruct" templateName:"bucket"`
	S3object     *string `awsName:"DiskContainers[0]UserBucket.S3Key" awsType:"awsslicestruct" templateName:"s3object"`
	// contains filtered or unexported fields
}

func NewImportImage

func NewImportImage(sess *session.Session, l ...*logger.Logger) *ImportImage

func (*ImportImage) DryRun

func (cmd *ImportImage) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*ImportImage) ExtractResult

func (cmd *ImportImage) ExtractResult(i interface{}) string

func (*ImportImage) ParamsHelp

func (cmd *ImportImage) ParamsHelp() string

func (*ImportImage) Run

func (cmd *ImportImage) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*ImportImage) SetApi

func (cmd *ImportImage) SetApi(api ec2iface.EC2API)

func (*ImportImage) ValidateCommand

func (cmd *ImportImage) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*ImportImage) ValidateParams

func (cmd *ImportImage) ValidateParams(params []string) ([]string, error)

type Platform

type Platform struct {
	Name          string
	Id            string
	DistroName    string
	LatestVariant string
	MatchFunc     func(s string, d Distro) bool
}

type ProgressReadSeeker

type ProgressReadSeeker struct {
	// contains filtered or unexported fields
}

func NewProgressReader

func NewProgressReader(f *os.File) (*ProgressReadSeeker, error)

func (*ProgressReadSeeker) Read

func (pr *ProgressReadSeeker) Read(p []byte) (int, error)

func (*ProgressReadSeeker) Seek

func (pr *ProgressReadSeeker) Seek(offset int64, whence int) (int64, error)

type ResultExtractor

type ResultExtractor interface {
	ExtractResult(interface{}) string
}

type StartAlarm

type StartAlarm struct {
	Names []*string `awsName:"AlarmNames" awsType:"awsstringslice" templateName:"names" required:""`
	// contains filtered or unexported fields
}

func NewStartAlarm

func NewStartAlarm(sess *session.Session, l ...*logger.Logger) *StartAlarm

func (*StartAlarm) DryRun

func (cmd *StartAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StartAlarm) ParamsHelp

func (cmd *StartAlarm) ParamsHelp() string

func (*StartAlarm) Run

func (cmd *StartAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StartAlarm) SetApi

func (cmd *StartAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*StartAlarm) ValidateCommand

func (cmd *StartAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StartAlarm) ValidateParams

func (cmd *StartAlarm) ValidateParams(params []string) ([]string, error)

type StartContainertask

type StartContainertask struct {
	Cluster                   *string `templateName:"cluster" required:""`
	DesiredCount              *int64  `templateName:"desired-count" required:""`
	Name                      *string `templateName:"name" required:""`
	Type                      *string `templateName:"type" required:""`
	Role                      *string `templateName:"role"`
	DeploymentName            *string `templateName:"deployment-name"`
	LoadBalancerContainerName *string `templateName:"loadbalancer.container-name"`
	LoadBalancerContainerPort *int64  `templateName:"loadbalancer.container-port"`
	LoadBalancerTargetgroup   *string `templateName:"loadbalancer.targetgroup"`
	// contains filtered or unexported fields
}

func NewStartContainertask

func NewStartContainertask(sess *session.Session, l ...*logger.Logger) *StartContainertask

func (*StartContainertask) DryRun

func (cmd *StartContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StartContainertask) ExtractResult

func (cmd *StartContainertask) ExtractResult(i interface{}) string

func (*StartContainertask) ManualRun

func (cmd *StartContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*StartContainertask) ParamsHelp

func (cmd *StartContainertask) ParamsHelp() string

func (*StartContainertask) Run

func (cmd *StartContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StartContainertask) SetApi

func (cmd *StartContainertask) SetApi(api ecsiface.ECSAPI)

func (*StartContainertask) ValidateCommand

func (cmd *StartContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StartContainertask) ValidateParams

func (cmd *StartContainertask) ValidateParams(params []string) ([]string, error)

func (*StartContainertask) Validate_Type

func (cmd *StartContainertask) Validate_Type() error

type StartInstance

type StartInstance struct {
	Id []*string `awsName:"InstanceIds" awsType:"awsstringslice" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewStartInstance

func NewStartInstance(sess *session.Session, l ...*logger.Logger) *StartInstance

func (*StartInstance) DryRun

func (cmd *StartInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StartInstance) ExtractResult

func (cmd *StartInstance) ExtractResult(i interface{}) string

func (*StartInstance) ParamsHelp

func (cmd *StartInstance) ParamsHelp() string

func (*StartInstance) Run

func (cmd *StartInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StartInstance) SetApi

func (cmd *StartInstance) SetApi(api ec2iface.EC2API)

func (*StartInstance) ValidateCommand

func (cmd *StartInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StartInstance) ValidateParams

func (cmd *StartInstance) ValidateParams(params []string) ([]string, error)

type StopAlarm

type StopAlarm struct {
	Names []*string `awsName:"AlarmNames" awsType:"awsstringslice" templateName:"names" required:""`
	// contains filtered or unexported fields
}

func NewStopAlarm

func NewStopAlarm(sess *session.Session, l ...*logger.Logger) *StopAlarm

func (*StopAlarm) DryRun

func (cmd *StopAlarm) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StopAlarm) ParamsHelp

func (cmd *StopAlarm) ParamsHelp() string

func (*StopAlarm) Run

func (cmd *StopAlarm) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StopAlarm) SetApi

func (cmd *StopAlarm) SetApi(api cloudwatchiface.CloudWatchAPI)

func (*StopAlarm) ValidateCommand

func (cmd *StopAlarm) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StopAlarm) ValidateParams

func (cmd *StopAlarm) ValidateParams(params []string) ([]string, error)

type StopContainertask

type StopContainertask struct {
	Cluster        *string `templateName:"cluster" required:""`
	Type           *string `templateName:"type" required:""`
	DeploymentName *string `templateName:"deployment-name"`
	RunArn         *string `templateName:"run-arn"`
	// contains filtered or unexported fields
}

func NewStopContainertask

func NewStopContainertask(sess *session.Session, l ...*logger.Logger) *StopContainertask

func (*StopContainertask) DryRun

func (cmd *StopContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StopContainertask) ManualRun

func (cmd *StopContainertask) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*StopContainertask) ParamsHelp

func (cmd *StopContainertask) ParamsHelp() string

func (*StopContainertask) Run

func (cmd *StopContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StopContainertask) SetApi

func (cmd *StopContainertask) SetApi(api ecsiface.ECSAPI)

func (*StopContainertask) ValidateCommand

func (cmd *StopContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StopContainertask) ValidateParams

func (cmd *StopContainertask) ValidateParams(params []string) ([]string, error)

func (*StopContainertask) Validate_Type

func (cmd *StopContainertask) Validate_Type() error

type StopInstance

type StopInstance struct {
	Id []*string `awsName:"InstanceIds" awsType:"awsstringslice" templateName:"id" required:""`
	// contains filtered or unexported fields
}

func NewStopInstance

func NewStopInstance(sess *session.Session, l ...*logger.Logger) *StopInstance

func (*StopInstance) DryRun

func (cmd *StopInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*StopInstance) ExtractResult

func (cmd *StopInstance) ExtractResult(i interface{}) string

func (*StopInstance) ParamsHelp

func (cmd *StopInstance) ParamsHelp() string

func (*StopInstance) Run

func (cmd *StopInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*StopInstance) SetApi

func (cmd *StopInstance) SetApi(api ec2iface.EC2API)

func (*StopInstance) ValidateCommand

func (cmd *StopInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*StopInstance) ValidateParams

func (cmd *StopInstance) ValidateParams(params []string) ([]string, error)

type UpdateBucket

type UpdateBucket struct {
	Name             *string `templateName:"name" required:""`
	Acl              *string `templateName:"acl"`
	PublicWebsite    *bool   `templateName:"public-website"`
	RedirectHostname *string `templateName:"redirect-hostname"`
	IndexSuffix      *string `templateName:"index-suffix"`
	EnforceHttps     *bool   `templateName:"enforce-https"`
	// contains filtered or unexported fields
}

func NewUpdateBucket

func NewUpdateBucket(sess *session.Session, l ...*logger.Logger) *UpdateBucket

func (*UpdateBucket) DryRun

func (cmd *UpdateBucket) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateBucket) ManualRun

func (cmd *UpdateBucket) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateBucket) ParamsHelp

func (cmd *UpdateBucket) ParamsHelp() string

func (*UpdateBucket) Run

func (cmd *UpdateBucket) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateBucket) SetApi

func (cmd *UpdateBucket) SetApi(api s3iface.S3API)

func (*UpdateBucket) ValidateCommand

func (cmd *UpdateBucket) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateBucket) ValidateParams

func (cmd *UpdateBucket) ValidateParams(params []string) ([]string, error)

type UpdateContainertask

type UpdateContainertask struct {
	Cluster        *string `awsName:"Cluster" awsType:"awsstr" templateName:"cluster" required:""`
	DeploymentName *string `awsName:"Service" awsType:"awsstr" templateName:"deployment-name" required:""`
	DesiredCount   *int64  `awsName:"DesiredCount" awsType:"awsint64" templateName:"desired-count"`
	Name           *string `awsName:"TaskDefinition" awsType:"awsstr" templateName:"name"`
	// contains filtered or unexported fields
}

func NewUpdateContainertask

func NewUpdateContainertask(sess *session.Session, l ...*logger.Logger) *UpdateContainertask

func (*UpdateContainertask) DryRun

func (cmd *UpdateContainertask) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateContainertask) ParamsHelp

func (cmd *UpdateContainertask) ParamsHelp() string

func (*UpdateContainertask) Run

func (cmd *UpdateContainertask) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateContainertask) SetApi

func (cmd *UpdateContainertask) SetApi(api ecsiface.ECSAPI)

func (*UpdateContainertask) ValidateCommand

func (cmd *UpdateContainertask) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateContainertask) ValidateParams

func (cmd *UpdateContainertask) ValidateParams(params []string) ([]string, error)

type UpdateDistribution

type UpdateDistribution struct {
	Id             *string   `awsName:"Id" awsType:"awsstr" templateName:"id" required:""`
	OriginDomain   *string   `templateName:"origin-domain"`
	Certificate    *string   `templateName:"certificate"`
	Comment        *string   `templateName:"comment"`
	DefaultFile    *string   `templateName:"default-file"`
	DomainAliases  []*string `templateName:"domain-aliases"`
	Enable         *bool     `templateName:"enable"`
	ForwardCookies *string   `templateName:"forward-cookies"`
	ForwardQueries *bool     `templateName:"forward-queries"`
	HttpsBehaviour *string   `templateName:"https-behaviour"`
	OriginPath     *string   `templateName:"origin-path"`
	PriceClass     *string   `templateName:"price-class"`
	MinTtl         *int64    `templateName:"min-ttl"`
	// contains filtered or unexported fields
}

func NewUpdateDistribution

func NewUpdateDistribution(sess *session.Session, l ...*logger.Logger) *UpdateDistribution

func (*UpdateDistribution) DryRun

func (cmd *UpdateDistribution) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateDistribution) ExtractResult

func (cmd *UpdateDistribution) ExtractResult(i interface{}) string

func (*UpdateDistribution) ManualRun

func (cmd *UpdateDistribution) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateDistribution) ParamsHelp

func (cmd *UpdateDistribution) ParamsHelp() string

func (*UpdateDistribution) Run

func (cmd *UpdateDistribution) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateDistribution) SetApi

func (cmd *UpdateDistribution) SetApi(api cloudfrontiface.CloudFrontAPI)

func (*UpdateDistribution) ValidateCommand

func (cmd *UpdateDistribution) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateDistribution) ValidateParams

func (cmd *UpdateDistribution) ValidateParams(params []string) ([]string, error)

type UpdateInstance

type UpdateInstance struct {
	Id   *string `awsName:"InstanceId" awsType:"awsstr" templateName:"id" required:""`
	Type *string `awsName:"InstanceType.Value" awsType:"awsstr" templateName:"type"`
	Lock *bool   `awsName:"DisableApiTermination" awsType:"awsboolattribute" templateName:"lock"`
	// contains filtered or unexported fields
}

func NewUpdateInstance

func NewUpdateInstance(sess *session.Session, l ...*logger.Logger) *UpdateInstance

func (*UpdateInstance) DryRun

func (cmd *UpdateInstance) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateInstance) ParamsHelp

func (cmd *UpdateInstance) ParamsHelp() string

func (*UpdateInstance) Run

func (cmd *UpdateInstance) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateInstance) SetApi

func (cmd *UpdateInstance) SetApi(api ec2iface.EC2API)

func (*UpdateInstance) ValidateCommand

func (cmd *UpdateInstance) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateInstance) ValidateParams

func (cmd *UpdateInstance) ValidateParams(params []string) ([]string, error)

type UpdateLoginprofile

type UpdateLoginprofile struct {
	Username      *string `awsName:"UserName" awsType:"awsstr" templateName:"username" required:""`
	Password      *string `awsName:"Password" awsType:"awsstr" templateName:"password" required:""`
	PasswordReset *bool   `awsName:"PasswordResetRequired" awsType:"awsbool" templateName:"password-reset"`
	// contains filtered or unexported fields
}

func NewUpdateLoginprofile

func NewUpdateLoginprofile(sess *session.Session, l ...*logger.Logger) *UpdateLoginprofile

func (*UpdateLoginprofile) DryRun

func (cmd *UpdateLoginprofile) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateLoginprofile) ParamsHelp

func (cmd *UpdateLoginprofile) ParamsHelp() string

func (*UpdateLoginprofile) Run

func (cmd *UpdateLoginprofile) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateLoginprofile) SetApi

func (cmd *UpdateLoginprofile) SetApi(api iamiface.IAMAPI)

func (*UpdateLoginprofile) ValidateCommand

func (cmd *UpdateLoginprofile) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateLoginprofile) ValidateParams

func (cmd *UpdateLoginprofile) ValidateParams(params []string) ([]string, error)

type UpdatePolicy

type UpdatePolicy struct {
	Arn            *string   `awsName:"PolicyArn" awsType:"awsstr" templateName:"arn" required:""`
	Effect         *string   `templateName:"effect" required:""`
	Action         []*string `templateName:"action" required:""`
	Resource       []*string `templateName:"resource" required:""`
	Conditions     []*string `templateName:"conditions"`
	Document       *string   `awsName:"PolicyDocument" awsType:"awsstr"`
	DefaultVersion *bool     `awsName:"SetAsDefault" awsType:"awsbool"`
	// contains filtered or unexported fields
}

func NewUpdatePolicy

func NewUpdatePolicy(sess *session.Session, l ...*logger.Logger) *UpdatePolicy

func (*UpdatePolicy) BeforeRun

func (cmd *UpdatePolicy) BeforeRun(ctx map[string]interface{}) error

func (*UpdatePolicy) DryRun

func (cmd *UpdatePolicy) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdatePolicy) ParamsHelp

func (cmd *UpdatePolicy) ParamsHelp() string

func (*UpdatePolicy) Run

func (cmd *UpdatePolicy) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdatePolicy) SetApi

func (cmd *UpdatePolicy) SetApi(api iamiface.IAMAPI)

func (*UpdatePolicy) ValidateCommand

func (cmd *UpdatePolicy) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdatePolicy) ValidateParams

func (cmd *UpdatePolicy) ValidateParams(params []string) ([]string, error)

type UpdateRecord

type UpdateRecord struct {
	Zone  *string `templateName:"zone" required:""`
	Name  *string `templateName:"name" required:""`
	Type  *string `templateName:"type" required:""`
	Value *string `templateName:"value" required:""`
	Ttl   *int64  `templateName:"ttl" required:""`
	// contains filtered or unexported fields
}

func NewUpdateRecord

func NewUpdateRecord(sess *session.Session, l ...*logger.Logger) *UpdateRecord

func (*UpdateRecord) DryRun

func (cmd *UpdateRecord) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateRecord) ExtractResult

func (cmd *UpdateRecord) ExtractResult(i interface{}) string

func (*UpdateRecord) ManualRun

func (cmd *UpdateRecord) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateRecord) ParamsHelp

func (cmd *UpdateRecord) ParamsHelp() string

func (*UpdateRecord) Run

func (cmd *UpdateRecord) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateRecord) SetApi

func (cmd *UpdateRecord) SetApi(api route53iface.Route53API)

func (*UpdateRecord) ValidateCommand

func (cmd *UpdateRecord) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateRecord) ValidateParams

func (cmd *UpdateRecord) ValidateParams(params []string) ([]string, error)

type UpdateS3object

type UpdateS3object struct {
	Bucket  *string `awsName:"Bucket" awsType:"awsstr" templateName:"bucket" required:""`
	Name    *string `awsName:"Key" awsType:"awsstr" templateName:"name" required:""`
	Acl     *string `awsName:"ACL" awsType:"awsstr" templateName:"acl" required:""`
	Version *string `awsName:"VersionId" awsType:"awsstr" templateName:"version"`
	// contains filtered or unexported fields
}

func NewUpdateS3object

func NewUpdateS3object(sess *session.Session, l ...*logger.Logger) *UpdateS3object

func (*UpdateS3object) DryRun

func (cmd *UpdateS3object) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateS3object) ParamsHelp

func (cmd *UpdateS3object) ParamsHelp() string

func (*UpdateS3object) Run

func (cmd *UpdateS3object) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateS3object) SetApi

func (cmd *UpdateS3object) SetApi(api s3iface.S3API)

func (*UpdateS3object) ValidateCommand

func (cmd *UpdateS3object) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateS3object) ValidateParams

func (cmd *UpdateS3object) ValidateParams(params []string) ([]string, error)

type UpdateScalinggroup

type UpdateScalinggroup struct {
	Name                   *string   `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name" required:""`
	Cooldown               *int64    `awsName:"DefaultCooldown" awsType:"awsint64" templateName:"cooldown"`
	DesiredCapacity        *int64    `awsName:"DesiredCapacity" awsType:"awsint64" templateName:"desired-capacity"`
	HealthcheckGracePeriod *int64    `awsName:"HealthCheckGracePeriod" awsType:"awsint64" templateName:"healthcheck-grace-period"`
	HealthcheckType        *string   `awsName:"HealthCheckType" awsType:"awsstr" templateName:"healthcheck-type"`
	Launchconfiguration    *string   `awsName:"LaunchConfigurationName" awsType:"awsstr" templateName:"launchconfiguration"`
	MaxSize                *int64    `awsName:"MaxSize" awsType:"awsint64" templateName:"max-size"`
	MinSize                *int64    `awsName:"MinSize" awsType:"awsint64" templateName:"min-size"`
	NewInstancesProtected  *bool     `awsName:"NewInstancesProtectedFromScaleIn" awsType:"awsbool" templateName:"new-instances-protected"`
	Subnets                []*string `awsName:"VPCZoneIdentifier" awsType:"awscsvstr" templateName:"subnets"`
	// contains filtered or unexported fields
}

func NewUpdateScalinggroup

func NewUpdateScalinggroup(sess *session.Session, l ...*logger.Logger) *UpdateScalinggroup

func (*UpdateScalinggroup) DryRun

func (cmd *UpdateScalinggroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateScalinggroup) ParamsHelp

func (cmd *UpdateScalinggroup) ParamsHelp() string

func (*UpdateScalinggroup) Run

func (cmd *UpdateScalinggroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateScalinggroup) SetApi

func (cmd *UpdateScalinggroup) SetApi(api autoscalingiface.AutoScalingAPI)

func (*UpdateScalinggroup) ValidateCommand

func (cmd *UpdateScalinggroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateScalinggroup) ValidateParams

func (cmd *UpdateScalinggroup) ValidateParams(params []string) ([]string, error)

type UpdateSecuritygroup

type UpdateSecuritygroup struct {
	Id            *string `templateName:"id" required:""`
	Protocol      *string `templateName:"protocol" required:""`
	CIDR          *string `templateName:"cidr"`
	Securitygroup *string `templateName:"securitygroup"`
	Inbound       *string `templateName:"inbound"`
	Outbound      *string `templateName:"outbound"`
	Portrange     *string `templateName:"portrange"`
	// contains filtered or unexported fields
}

func NewUpdateSecuritygroup

func NewUpdateSecuritygroup(sess *session.Session, l ...*logger.Logger) *UpdateSecuritygroup

func (*UpdateSecuritygroup) DryRun

func (cmd *UpdateSecuritygroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSecuritygroup) ManualRun

func (cmd *UpdateSecuritygroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateSecuritygroup) ParamsHelp

func (cmd *UpdateSecuritygroup) ParamsHelp() string

func (*UpdateSecuritygroup) Run

func (cmd *UpdateSecuritygroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSecuritygroup) SetApi

func (cmd *UpdateSecuritygroup) SetApi(api ec2iface.EC2API)

func (*UpdateSecuritygroup) ValidateCommand

func (cmd *UpdateSecuritygroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateSecuritygroup) ValidateParams

func (cmd *UpdateSecuritygroup) ValidateParams(params []string) ([]string, error)

func (*UpdateSecuritygroup) Validate_CIDR

func (cmd *UpdateSecuritygroup) Validate_CIDR() error

func (*UpdateSecuritygroup) Validate_Inbound

func (cmd *UpdateSecuritygroup) Validate_Inbound() error

func (*UpdateSecuritygroup) Validate_Outbound

func (cmd *UpdateSecuritygroup) Validate_Outbound() error

type UpdateStack

type UpdateStack struct {
	Name                *string   `awsName:"StackName" awsType:"awsstr" templateName:"name" required:""`
	Capabilities        []*string `awsName:"Capabilities" awsType:"awsstringslice" templateName:"capabilities"`
	Notifications       []*string `awsName:"NotificationARNs" awsType:"awsstringslice" templateName:"notifications"`
	Parameters          []*string `awsName:"Parameters" awsType:"awsparameterslice" templateName:"parameters"`
	ResourceTypes       []*string `awsName:"ResourceTypes" awsType:"awsstringslice" templateName:"resource-types"`
	Role                *string   `awsName:"RoleARN" awsType:"awsstr" templateName:"role"`
	PolicyFile          *string   `awsName:"StackPolicyBody" awsType:"awsfiletostring" templateName:"policy-file"`
	PolicyUpdateFile    *string   `awsName:"StackPolicyDuringUpdateBody" awsType:"awsfiletostring" templateName:"policy-update-file"`
	TemplateFile        *string   `awsName:"TemplateBody" awsType:"awsfiletostring" templateName:"template-file"`
	UsePreviousTemplate *bool     `awsName:"UsePreviousTemplate" awsType:"awsbool" templateName:"use-previous-template"`
	// contains filtered or unexported fields
}

func NewUpdateStack

func NewUpdateStack(sess *session.Session, l ...*logger.Logger) *UpdateStack

func (*UpdateStack) DryRun

func (cmd *UpdateStack) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateStack) ExtractResult

func (cmd *UpdateStack) ExtractResult(i interface{}) string

func (*UpdateStack) ParamsHelp

func (cmd *UpdateStack) ParamsHelp() string

func (*UpdateStack) Run

func (cmd *UpdateStack) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateStack) SetApi

func (cmd *UpdateStack) SetApi(api cloudformationiface.CloudFormationAPI)

func (*UpdateStack) ValidateCommand

func (cmd *UpdateStack) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateStack) ValidateParams

func (cmd *UpdateStack) ValidateParams(params []string) ([]string, error)

type UpdateSubnet

type UpdateSubnet struct {
	Id     *string `awsName:"SubnetId" awsType:"awsstr" templateName:"id" required:""`
	Public *bool   `awsName:"MapPublicIpOnLaunch" awsType:"awsboolattribute" templateName:"public"`
	// contains filtered or unexported fields
}

func NewUpdateSubnet

func NewUpdateSubnet(sess *session.Session, l ...*logger.Logger) *UpdateSubnet

func (*UpdateSubnet) DryRun

func (cmd *UpdateSubnet) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSubnet) ParamsHelp

func (cmd *UpdateSubnet) ParamsHelp() string

func (*UpdateSubnet) Run

func (cmd *UpdateSubnet) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateSubnet) SetApi

func (cmd *UpdateSubnet) SetApi(api ec2iface.EC2API)

func (*UpdateSubnet) ValidateCommand

func (cmd *UpdateSubnet) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateSubnet) ValidateParams

func (cmd *UpdateSubnet) ValidateParams(params []string) ([]string, error)

type UpdateTargetgroup

type UpdateTargetgroup struct {
	Id                  *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"id" required:""`
	Deregistrationdelay *string `awsType:"awsstr" templateName:"deregistrationdelay"`
	Stickiness          *string `awsType:"awsstr" templateName:"stickiness"`
	Stickinessduration  *string `awsType:"awsstr" templateName:"stickinessduration"`
	Healthcheckinterval *int64  `awsName:"HealthCheckIntervalSeconds" awsType:"awsint64" templateName:"healthcheckinterval"`
	Healthcheckpath     *string `awsName:"HealthCheckPath" awsType:"awsstr" templateName:"healthcheckpath"`
	Healthcheckport     *string `awsName:"HealthCheckPort" awsType:"awsstr" templateName:"healthcheckport"`
	Healthcheckprotocol *string `awsName:"HealthCheckProtocol" awsType:"awsstr" templateName:"healthcheckprotocol"`
	Healthchecktimeout  *int64  `awsName:"HealthCheckTimeoutSeconds" awsType:"awsint64" templateName:"healthchecktimeout"`
	Healthythreshold    *int64  `awsName:"HealthyThresholdCount" awsType:"awsint64" templateName:"healthythreshold"`
	Unhealthythreshold  *int64  `awsName:"UnhealthyThresholdCount" awsType:"awsint64" templateName:"unhealthythreshold"`
	Matcher             *string `awsName:"Matcher.HttpCode" awsType:"awsstr" templateName:"matcher"`
	// contains filtered or unexported fields
}

func NewUpdateTargetgroup

func NewUpdateTargetgroup(sess *session.Session, l ...*logger.Logger) *UpdateTargetgroup

func (*UpdateTargetgroup) DryRun

func (cmd *UpdateTargetgroup) DryRun(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateTargetgroup) ManualRun

func (tg *UpdateTargetgroup) ManualRun(ctx map[string]interface{}) (interface{}, error)

func (*UpdateTargetgroup) ParamsHelp

func (cmd *UpdateTargetgroup) ParamsHelp() string

func (*UpdateTargetgroup) Run

func (cmd *UpdateTargetgroup) Run(ctx, params map[string]interface{}) (interface{}, error)

func (*UpdateTargetgroup) SetApi

func (cmd *UpdateTargetgroup) SetApi(api elbv2iface.ELBV2API)

func (*UpdateTargetgroup) ValidateCommand

func (cmd *UpdateTargetgroup) ValidateCommand(params map[string]interface{}, refs []string) (errs []error)

func (*UpdateTargetgroup) ValidateParams

func (cmd *UpdateTargetgroup) ValidateParams(params []string) ([]string, error)