awsspec

package
v1.3.0 Latest Latest
Warning

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

 Go to latest Published: Aug 11, 2026 License: Apache-2.0 Imports: 105 Imported by: 0

Documentation

Overview

DO NOT EDIT This file was automatically generated with go generate

DO NOT EDIT This file was automatically generated with go generate

DO NOT EDIT This file was automatically generated with go generate 

Copyright 2017 WALLIX

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

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

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

Copyright 2017 WALLIX

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

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

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

Copyright 2017 WALLIX

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

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

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

Copyright 2017 WALLIX

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

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

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

Index

Constants

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

Variables

View Source 
var (
	Platforms = map[string]Platform{
		"canonical":   Canonical,
		"redhat":      RedHat,
		"debian":      Debian,
		"amazonlinux": AmazonLinux,
		"coreos":      CoreOS,
		"centos":      CentOS,
		"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.5",
		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: "stretch",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, fmt.Sprintf("%s-%s", d.Name, d.Variant))
		},
	}

	CoreOS = Platform{
		Name: "coreos", ID: "595879546273", DistroName: "coreos", LatestVariant: "1688",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, strings.ToLower(fmt.Sprintf("%s-stable-%s", d.Name, d.Variant)))
		},
	}

	CentOS = Platform{
		Name: "centos", ID: "679593333241", DistroName: "centos", LatestVariant: "7",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, strings.ToLower(fmt.Sprintf("%s Linux %s", d.Name, d.Variant)))
		},
	}

	AmazonLinux = Platform{
		Name: "amazonlinux", ID: "137112412989", DistroName: "amzn", LatestVariant: "hvm",
		MatchFunc: func(s string, d Distro) bool {
			return strings.HasPrefix(s, fmt.Sprintf("%s-ami-%s", d.Name, 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
)
View Source 
var APIPerTemplateDefName = map[string]string{}/* 304 elements not displayed */
View Source 
var (
	AWSCredFilepath = filepath.Join(awsconfig.AWSHomeDir(), "credentials")
)
View Source 
var AWSTemplatesDefinitions = map[string]Definition{}/* 304 elements not displayed */
View Source 
var CallerReferenceFunc = func() string {
	return fmt.Sprint(time.Now().UTC().Unix())
}
View Source 
var DefaultImageResolverCache = new(ImageResolverCache)
View Source 
var DriverSupportedActions = map[string][]string{
	"attach":       []string{"alarm", "classicloadbalancer", "containertask", "elasticip", "eventtarget", "instance", "instanceprofile", "internetgateway", "listener", "mfadevice", "networkinterface", "policy", "role", "routetable", "securitygroup", "user", "volume"},
	"authenticate": []string{"registry"},
	"check":        []string{"certificate", "database", "distribution", "instance", "loadbalancer", "natgateway", "networkinterface", "scalinggroup", "securitygroup", "volume"},
	"copy":         []string{"image", "snapshot"},
	"create":       []string{"accelerator", "acceleratorlistener", "accesskey", "alarm", "apigateway", "apigatewayroute", "apigatewaystage", "application", "appscalingpolicy", "appscalingtarget", "backupplan", "backupvault", "broker", "bucket", "buildproject", "cachecluster", "cachesubnetgroup", "certificate", "classicloadbalancer", "configrule", "configurationset", "containercluster", "crawler", "database", "dbsubnetgroup", "deployapplication", "deployment", "deploymentgroup", "discoveryservice", "distribution", "dynamodbtable", "ekscluster", "eksnodegroup", "elasticip", "emailidentity", "environment", "eventbus", "eventrule", "filesystem", "fsxbackup", "fsxfilesystem", "function", "gluedatabase", "group", "identitypool", "image", "instance", "instanceprofile", "internetgateway", "ipset", "job", "kafkacluster", "keypair", "launchconfiguration", "listener", "loadbalancer", "loggroup", "loginprofile", "mfadevice", "namespace", "natgateway", "networkinterface", "pipeline", "policy", "queue", "record", "redshiftcluster", "redshiftsubnetgroup", "replicationgroup", "repository", "role", "route", "routetable", "rulegroup", "s3object", "scalinggroup", "scalingpolicy", "secret", "securitygroup", "snapshot", "ssmparameter", "stack", "statemachine", "stream", "subnet", "subscription", "tag", "targetgroup", "topic", "trail", "transitgateway", "transitgatewayattachment", "transitgatewayroutetable", "user", "userpool", "volume", "vpc", "vpcendpoint", "vpcpeering", "webacl", "zone"},
	"delete":       []string{"accelerator", "acceleratorlistener", "accesskey", "alarm", "apigateway", "apigatewayroute", "apigatewaystage", "application", "appscalingpolicy", "appscalingtarget", "backupplan", "backupvault", "broker", "bucket", "buildproject", "cachecluster", "cachesubnetgroup", "certificate", "classicloadbalancer", "configrule", "configurationset", "containercluster", "containertask", "crawler", "database", "dbsubnetgroup", "deployapplication", "deploymentgroup", "discoveryservice", "distribution", "dynamodbtable", "ekscluster", "eksnodegroup", "elasticip", "emailidentity", "environment", "eventbus", "eventrule", "filesystem", "fsxbackup", "fsxfilesystem", "function", "gluedatabase", "group", "identitypool", "image", "instance", "instanceprofile", "internetgateway", "ipset", "job", "kafkacluster", "keypair", "launchconfiguration", "listener", "loadbalancer", "loggroup", "loginprofile", "mfadevice", "namespace", "natgateway", "networkinterface", "pipeline", "policy", "queue", "record", "redshiftcluster", "redshiftsubnetgroup", "replicationgroup", "repository", "role", "route", "routetable", "rulegroup", "s3object", "scalinggroup", "scalingpolicy", "secret", "securitygroup", "snapshot", "ssmparameter", "stack", "statemachine", "stream", "subnet", "subscription", "tag", "targetgroup", "topic", "trail", "transitgateway", "transitgatewayattachment", "transitgatewayroutetable", "user", "userpool", "volume", "vpc", "vpcendpoint", "vpcpeering", "webacl", "zone"},
	"detach":       []string{"alarm", "classicloadbalancer", "containertask", "elasticip", "eventtarget", "instance", "instanceprofile", "internetgateway", "mfadevice", "networkinterface", "policy", "role", "routetable", "securitygroup", "user", "volume"},
	"import":       []string{"image"},
	"restart":      []string{"database", "instance"},
	"start":        []string{"alarm", "buildproject", "containertask", "crawler", "database", "eventrule", "execution", "instance", "job", "pipeline", "trail", "vpcpeering"},
	"stop":         []string{"alarm", "buildproject", "containertask", "crawler", "database", "deployment", "eventrule", "execution", "instance", "pipeline", "trail"},
	"update":       []string{"accelerator", "application", "bucket", "buildproject", "cachecluster", "cachesubnetgroup", "classicloadbalancer", "configrule", "containertask", "distribution", "environment", "eventrule", "image", "instance", "ipset", "loggroup", "loginprofile", "policy", "record", "redshiftcluster", "s3object", "scalinggroup", "secret", "securitygroup", "ssmparameter", "stack", "statemachine", "stream", "subnet", "targetgroup"},
}
View Source 
var MockAWSSessionFactory = &AWSFactory{
	Log: logger.DiscardLogger,
	Cfg: aws.Config{},
}
View Source 
var ProgressBarFactory func(*os.File) (*ProgressReadSeeker, error)

Allow to control for testing

Functions

func Bool 

func Bool(v bool) *bool

func BoolValue 

func BoolValue(v *bool) bool

func Int64 

func Int64(v int64) *int64

func Int64AsIntValue 

func Int64AsIntValue(v *int64) int

func NewCredsPrompter 

func NewCredsPrompter(profile string) *credentialsPrompter

func NewEnumValidator 

func NewEnumValidator(expected ...string) *enumValidator

func String 

func String(v string) *string

func StringValue 

func StringValue(v *string) string

Types

type AWSFactory 

type AWSFactory struct {
	Log   *logger.Logger
	Cfg   aws.Config
	Graph cloud.GraphAPI
}

func (*AWSFactory) Build 

func (f *AWSFactory) Build(key string) func() any

type AfterRunner 

type AfterRunner interface {
	AfterRun(env.Running, any) error
}

type AttachAlarm 

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

func NewAttachAlarm 

func NewAttachAlarm(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachAlarm

func (*AttachAlarm) ManualRun 

func (cmd *AttachAlarm) ManualRun(renv env.Running) (any, error)

func (*AttachAlarm) ParamsSpec 

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

func (*AttachAlarm) Run 

func (cmd *AttachAlarm) Run(renv env.Running, params map[string]any) (any, error)

type AttachClassicLoadbalancer 

type AttachClassicLoadbalancer struct {
	Name     *string `awsName:"LoadBalancerName" awsType:"awsstr" templateName:"name"`
	Instance *string `awsName:"Instances[0]InstanceId" awsType:"awsslicestruct" templateName:"instance"`
	// contains filtered or unexported fields
}

func NewAttachClassicLoadbalancer 

func NewAttachClassicLoadbalancer(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachClassicLoadbalancer

func (*AttachClassicLoadbalancer) ExtractResult 

func (cmd *AttachClassicLoadbalancer) ExtractResult(any) string

func (*AttachClassicLoadbalancer) ParamsSpec 

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

func (*AttachClassicLoadbalancer) Run 

func (cmd *AttachClassicLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type AttachContainertask 

type AttachContainertask struct {
	Name            *string   `templateName:"name"`
	ContainerName   *string   `templateName:"container-name"`
	Image           *string   `templateName:"image"`
	MemoryHardLimit *int64    `templateName:"memory-hard-limit"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachContainertask

func (*AttachContainertask) ExtractResult 

func (cmd *AttachContainertask) ExtractResult(i any) string

func (*AttachContainertask) ManualRun 

func (cmd *AttachContainertask) ManualRun(renv env.Running) (any, error)

func (*AttachContainertask) ParamsSpec 

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

func (*AttachContainertask) Run 

func (cmd *AttachContainertask) Run(renv env.Running, params map[string]any) (any, error)

type AttachElasticip 

type AttachElasticip struct {
	ID                 *string `awsName:"AllocationId" awsType:"awsstr" templateName:"id"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachElasticip

func (*AttachElasticip) ExtractResult 

func (cmd *AttachElasticip) ExtractResult(i any) string

func (*AttachElasticip) ParamsSpec 

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

func (*AttachElasticip) Run 

func (cmd *AttachElasticip) Run(renv env.Running, params map[string]any) (any, error)

type AttachEventtarget added in v1.2.0 

type AttachEventtarget struct {
	Rule     *string `awsName:"Rule" awsType:"awsstr" templateName:"rule"`
	ID       *string `awsName:"Targets[0]Id" awsType:"awsslicestruct" templateName:"id"`
	Arn      *string `awsName:"Targets[0]Arn" awsType:"awsslicestruct" templateName:"arn"`
	Role     *string `awsName:"Targets[0]RoleArn" awsType:"awsslicestruct" templateName:"role"`
	Input    *string `awsName:"Targets[0]Input" awsType:"awsslicestruct" templateName:"input"`
	EventBus *string `awsName:"EventBusName" awsType:"awsstr" templateName:"eventbus"`
	// contains filtered or unexported fields
}

Targets are attached to a rule rather than existing independently, so they are an attach/detach pair rather than a resource with its own lifecycle. PutTargets takes a slice of structs; the indexed paths below all address element zero, which the setter merges into a single target.

func NewAttachEventtarget added in v1.2.0 

func NewAttachEventtarget(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachEventtarget

func (*AttachEventtarget) ExtractResult added in v1.2.0 

func (cmd *AttachEventtarget) ExtractResult(i any) string

func (*AttachEventtarget) ParamsSpec added in v1.2.0 

func (cmd *AttachEventtarget) ParamsSpec() params.Spec

func (*AttachEventtarget) Run added in v1.2.0 

func (cmd *AttachEventtarget) Run(renv env.Running, params map[string]any) (any, error)

type AttachInstance 

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

func NewAttachInstance 

func NewAttachInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachInstance

func (*AttachInstance) ParamsSpec 

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

func (*AttachInstance) Run 

func (cmd *AttachInstance) Run(renv env.Running, params map[string]any) (any, error)

type AttachInstanceprofile 

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

func NewAttachInstanceprofile 

func NewAttachInstanceprofile(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachInstanceprofile

func (*AttachInstanceprofile) ManualRun 

func (cmd *AttachInstanceprofile) ManualRun(renv env.Running) (any, error)

func (*AttachInstanceprofile) ParamsSpec 

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

func (*AttachInstanceprofile) Run 

func (cmd *AttachInstanceprofile) Run(renv env.Running, params map[string]any) (any, error)

type AttachInternetgateway 

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

func NewAttachInternetgateway 

func NewAttachInternetgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachInternetgateway

func (*AttachInternetgateway) ParamsSpec 

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

func (*AttachInternetgateway) Run 

func (cmd *AttachInternetgateway) Run(renv env.Running, params map[string]any) (any, error)

type AttachListener 

type AttachListener struct {
	ID          *string `awsName:"ListenerArn" awsType:"awsstr" templateName:"id"`
	Certificate *string `awsName:"Certificates[0]CertificateArn" awsType:"awsslicestruct" templateName:"certificate"`
	// contains filtered or unexported fields
}

func NewAttachListener 

func NewAttachListener(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachListener

func (*AttachListener) ParamsSpec 

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

func (*AttachListener) Run 

func (cmd *AttachListener) Run(renv env.Running, params map[string]any) (any, error)

type AttachMfadevice 

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

func NewAttachMfadevice 

func NewAttachMfadevice(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachMfadevice

func (*AttachMfadevice) AfterRun 

func (cmd *AttachMfadevice) AfterRun(renv env.Running, output any) error

func (*AttachMfadevice) ParamsSpec 

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

func (*AttachMfadevice) Run 

func (cmd *AttachMfadevice) Run(renv env.Running, params map[string]any) (any, error)

type AttachNetworkinterface 

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

func NewAttachNetworkinterface 

func NewAttachNetworkinterface(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachNetworkinterface

func (*AttachNetworkinterface) ExtractResult 

func (cmd *AttachNetworkinterface) ExtractResult(i any) string

func (*AttachNetworkinterface) ParamsSpec 

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

func (*AttachNetworkinterface) Run 

func (cmd *AttachNetworkinterface) Run(renv env.Running, params map[string]any) (any, 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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachPolicy

func (*AttachPolicy) ManualRun 

func (cmd *AttachPolicy) ManualRun(renv env.Running) (any, error)

func (*AttachPolicy) ParamsSpec 

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

func (*AttachPolicy) Run 

func (cmd *AttachPolicy) Run(renv env.Running, params map[string]any) (any, error)

type AttachRole 

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

func NewAttachRole 

func NewAttachRole(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachRole

func (*AttachRole) ParamsSpec 

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

func (*AttachRole) Run 

func (cmd *AttachRole) Run(renv env.Running, params map[string]any) (any, error)

type AttachRoutetable 

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

func NewAttachRoutetable 

func NewAttachRoutetable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachRoutetable

func (*AttachRoutetable) ExtractResult 

func (cmd *AttachRoutetable) ExtractResult(i any) string

func (*AttachRoutetable) ParamsSpec 

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

func (*AttachRoutetable) Run 

func (cmd *AttachRoutetable) Run(renv env.Running, params map[string]any) (any, error)

type AttachSecuritygroup 

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

func NewAttachSecuritygroup 

func NewAttachSecuritygroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachSecuritygroup

func (*AttachSecuritygroup) ManualRun 

func (cmd *AttachSecuritygroup) ManualRun(renv env.Running) (any, error)

func (*AttachSecuritygroup) ParamsSpec 

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

func (*AttachSecuritygroup) Run 

func (cmd *AttachSecuritygroup) Run(renv env.Running, params map[string]any) (any, error)

type AttachUser 

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

func NewAttachUser 

func NewAttachUser(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachUser

func (*AttachUser) ParamsSpec 

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

func (*AttachUser) Run 

func (cmd *AttachUser) Run(renv env.Running, params map[string]any) (any, error)

type AttachVolume 

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

func NewAttachVolume 

func NewAttachVolume(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AttachVolume

func (*AttachVolume) ExtractResult 

func (cmd *AttachVolume) ExtractResult(i any) string

func (*AttachVolume) ParamsSpec 

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

func (*AttachVolume) Run 

func (cmd *AttachVolume) Run(renv env.Running, params map[string]any) (any, 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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *AuthenticateRegistry

func (*AuthenticateRegistry) ManualRun 

func (cmd *AuthenticateRegistry) ManualRun(renv env.Running) (any, error)

func (*AuthenticateRegistry) ParamsSpec 

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

func (*AuthenticateRegistry) Run 

func (cmd *AuthenticateRegistry) Run(renv env.Running, params map[string]any) (any, error)

type AwsImage 

type AwsImage struct {
	ID                 string    `json:"Id"`
	Owner              string    `json:"Owner"`
	Location           string    `json:"Location"`
	Type               string    `json:"Type"`
	Architecture       string    `json:"Architecture"`
	VirtualizationType string    `json:"VirtualizationType"`
	Name               string    `json:"Name"`
	Created            time.Time `json:"Created"`
	Hypervisor         string    `json:"Hypervisor"`
	Store              string    `json:"Store"`
}

AwsImage is rendered by `awless search images --format json`, so its field names are a wire contract. The json tags are explicit for that reason: the ID field was briefly renamed from Id without one, which silently changed the output key.

type BeforeRunner 

type BeforeRunner interface {
	BeforeRun(env.Running) error
}

type CheckCertificate 

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

func NewCheckCertificate 

func NewCheckCertificate(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckCertificate

func (*CheckCertificate) ManualRun 

func (cmd *CheckCertificate) ManualRun(renv env.Running) (any, error)

func (*CheckCertificate) ParamsSpec 

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

func (*CheckCertificate) Run 

func (cmd *CheckCertificate) Run(renv env.Running, params map[string]any) (any, error)

type CheckDatabase 

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

func NewCheckDatabase 

func NewCheckDatabase(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckDatabase

func (*CheckDatabase) ManualRun 

func (cmd *CheckDatabase) ManualRun(renv env.Running) (any, error)

func (*CheckDatabase) ParamsSpec 

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

func (*CheckDatabase) Run 

func (cmd *CheckDatabase) Run(renv env.Running, params map[string]any) (any, error)

type CheckDistribution 

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

func NewCheckDistribution 

func NewCheckDistribution(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckDistribution

func (*CheckDistribution) ManualRun 

func (cmd *CheckDistribution) ManualRun(renv env.Running) (any, error)

func (*CheckDistribution) ParamsSpec 

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

func (*CheckDistribution) Run 

func (cmd *CheckDistribution) Run(renv env.Running, params map[string]any) (any, error)

type CheckInstance 

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

func NewCheckInstance 

func NewCheckInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckInstance

func (*CheckInstance) ManualRun 

func (cmd *CheckInstance) ManualRun(renv env.Running) (any, error)

func (*CheckInstance) ParamsSpec 

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

func (*CheckInstance) Run 

func (cmd *CheckInstance) Run(renv env.Running, params map[string]any) (any, error)

type CheckLoadbalancer 

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

func NewCheckLoadbalancer 

func NewCheckLoadbalancer(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckLoadbalancer

func (*CheckLoadbalancer) ManualRun 

func (cmd *CheckLoadbalancer) ManualRun(renv env.Running) (any, error)

func (*CheckLoadbalancer) ParamsSpec 

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

func (*CheckLoadbalancer) Run 

func (cmd *CheckLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type CheckNatgateway 

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

func NewCheckNatgateway 

func NewCheckNatgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckNatgateway

func (*CheckNatgateway) ManualRun 

func (cmd *CheckNatgateway) ManualRun(renv env.Running) (any, error)

func (*CheckNatgateway) ParamsSpec 

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

func (*CheckNatgateway) Run 

func (cmd *CheckNatgateway) Run(renv env.Running, params map[string]any) (any, error)

type CheckNetworkinterface 

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

func NewCheckNetworkinterface 

func NewCheckNetworkinterface(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckNetworkinterface

func (*CheckNetworkinterface) ManualRun 

func (cmd *CheckNetworkinterface) ManualRun(renv env.Running) (any, error)

func (*CheckNetworkinterface) ParamsSpec 

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

func (*CheckNetworkinterface) Run 

func (cmd *CheckNetworkinterface) Run(renv env.Running, params map[string]any) (any, error)

type CheckScalinggroup 

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

func NewCheckScalinggroup 

func NewCheckScalinggroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckScalinggroup

func (*CheckScalinggroup) ManualRun 

func (cmd *CheckScalinggroup) ManualRun(renv env.Running) (any, error)

func (*CheckScalinggroup) ParamsSpec 

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

func (*CheckScalinggroup) Run 

func (cmd *CheckScalinggroup) Run(renv env.Running, params map[string]any) (any, error)

type CheckSecuritygroup 

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

func NewCheckSecuritygroup 

func NewCheckSecuritygroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckSecuritygroup

func (*CheckSecuritygroup) ManualRun 

func (cmd *CheckSecuritygroup) ManualRun(renv env.Running) (any, error)

func (*CheckSecuritygroup) ParamsSpec 

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

func (*CheckSecuritygroup) Run 

func (cmd *CheckSecuritygroup) Run(renv env.Running, params map[string]any) (any, error)

type CheckVolume 

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

func NewCheckVolume 

func NewCheckVolume(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CheckVolume

func (*CheckVolume) ManualRun 

func (cmd *CheckVolume) ManualRun(renv env.Running) (any, error)

func (*CheckVolume) ParamsSpec 

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

func (*CheckVolume) Run 

func (cmd *CheckVolume) Run(renv env.Running, params map[string]any) (any, error)

type CopyImage 

type CopyImage struct {
	Name         *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	SourceID     *string `awsName:"SourceImageId" awsType:"awsstr" templateName:"source-id"`
	SourceRegion *string `awsName:"SourceRegion" awsType:"awsstr" templateName:"source-region"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CopyImage

func (*CopyImage) ExtractResult 

func (cmd *CopyImage) ExtractResult(i any) string

func (*CopyImage) ParamsSpec 

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

func (*CopyImage) Run 

func (cmd *CopyImage) Run(renv env.Running, params map[string]any) (any, error)

type CopySnapshot 

type CopySnapshot struct {
	SourceID     *string `awsName:"SourceSnapshotId" awsType:"awsstr" templateName:"source-id"`
	SourceRegion *string `awsName:"SourceRegion" awsType:"awsstr" templateName:"source-region"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CopySnapshot

func (*CopySnapshot) ExtractResult 

func (cmd *CopySnapshot) ExtractResult(i any) string

func (*CopySnapshot) ParamsSpec 

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

func (*CopySnapshot) Run 

func (cmd *CopySnapshot) Run(renv env.Running, params map[string]any) (any, error)

type CreateAccelerator added in v1.2.0 

type CreateAccelerator struct {
	Name    *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Enabled *bool   `awsName:"Enabled" awsType:"awsbool" templateName:"enabled"`
	IPType  *string `awsName:"IpAddressType" awsType:"awsstr" templateName:"ip-type"`
	// Required by the API. Generated rather than asked for: it exists to make a retried
	// call idempotent, which is machinery rather than a decision the user should make.
	Token *string `awsName:"IdempotencyToken" awsType:"awsstr" templateName:"token"`
	// contains filtered or unexported fields
}

func NewCreateAccelerator added in v1.2.0 

func NewCreateAccelerator(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateAccelerator

func (*CreateAccelerator) BeforeRun added in v1.2.0 

func (cmd *CreateAccelerator) BeforeRun(renv env.Running) error

func (*CreateAccelerator) ExtractResult added in v1.2.0 

func (cmd *CreateAccelerator) ExtractResult(i any) string

func (*CreateAccelerator) ParamsSpec added in v1.2.0 

func (cmd *CreateAccelerator) ParamsSpec() params.Spec

func (*CreateAccelerator) Run added in v1.2.0 

func (cmd *CreateAccelerator) Run(renv env.Running, params map[string]any) (any, error)

type CreateAcceleratorlistener added in v1.2.0 

type CreateAcceleratorlistener struct {
	Accelerator *string `awsName:"AcceleratorArn" awsType:"awsstr" templateName:"accelerator"`
	Protocol    *string `awsName:"Protocol" awsType:"awsstr" templateName:"protocol"`
	// Port ranges are a list of from/to pairs, so they come from a file rather than being
	// squeezed into a flag.
	PortsFile *string `awsName:"PortRanges" awsType:"awsfiletostruct" templateName:"ports-file"`
	Affinity  *string `awsName:"ClientAffinity" awsType:"awsstr" templateName:"client-affinity"`
	Token     *string `awsName:"IdempotencyToken" awsType:"awsstr" templateName:"token"`
	// contains filtered or unexported fields
}

func NewCreateAcceleratorlistener added in v1.2.0 

func NewCreateAcceleratorlistener(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateAcceleratorlistener

func (*CreateAcceleratorlistener) BeforeRun added in v1.2.0 

func (cmd *CreateAcceleratorlistener) BeforeRun(renv env.Running) error

func (*CreateAcceleratorlistener) ExtractResult added in v1.2.0 

func (cmd *CreateAcceleratorlistener) ExtractResult(i any) string

func (*CreateAcceleratorlistener) ParamsSpec added in v1.2.0 

func (cmd *CreateAcceleratorlistener) ParamsSpec() params.Spec

func (*CreateAcceleratorlistener) Run added in v1.2.0 

func (cmd *CreateAcceleratorlistener) Run(renv env.Running, params map[string]any) (any, error)

type CreateAccesskey 

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

func NewCreateAccesskey 

func NewCreateAccesskey(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateAccesskey

func (*CreateAccesskey) AfterRun 

func (cmd *CreateAccesskey) AfterRun(renv env.Running, output any) error

func (*CreateAccesskey) ExtractResult 

func (cmd *CreateAccesskey) ExtractResult(i any) string

func (*CreateAccesskey) ParamsSpec 

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

func (*CreateAccesskey) Run 

func (cmd *CreateAccesskey) Run(renv env.Running, params map[string]any) (any, error)

type CreateAlarm 

type CreateAlarm struct {
	Name                    *string   `awsName:"AlarmName" awsType:"awsstr" templateName:"name"`
	Operator                *string   `awsName:"ComparisonOperator" awsType:"awsstr" templateName:"operator"`
	Metric                  *string   `awsName:"MetricName" awsType:"awsstr" templateName:"metric"`
	Namespace               *string   `awsName:"Namespace" awsType:"awsstr" templateName:"namespace"`
	EvaluationPeriods       *int64    `awsName:"EvaluationPeriods" awsType:"awsint64" templateName:"evaluation-periods"`
	Period                  *int64    `awsName:"Period" awsType:"awsint64" templateName:"period"`
	StatisticFunction       *string   `awsName:"Statistic" awsType:"awsstr" templateName:"statistic-function"`
	Threshold               *float64  `awsName:"Threshold" awsType:"awsfloat" templateName:"threshold"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateAlarm

func (*CreateAlarm) ExtractResult 

func (cmd *CreateAlarm) ExtractResult(i any) string

func (*CreateAlarm) ParamsSpec 

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

func (*CreateAlarm) Run 

func (cmd *CreateAlarm) Run(renv env.Running, params map[string]any) (any, error)

type CreateApigateway 

type CreateApigateway struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Protocol    *string `awsName:"ProtocolType" awsType:"awsstr" templateName:"protocol"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	Target      *string `awsName:"Target" awsType:"awsstr" templateName:"target"`
	Version     *string `awsName:"Version" awsType:"awsstr" templateName:"version"`
	RouteKey    *string `awsName:"RouteKey" awsType:"awsstr" templateName:"route-key"`
	// contains filtered or unexported fields
}

func NewCreateApigateway 

func NewCreateApigateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateApigateway

func (*CreateApigateway) ExtractResult 

func (cmd *CreateApigateway) ExtractResult(i any) string

func (*CreateApigateway) ParamsSpec 

func (cmd *CreateApigateway) ParamsSpec() params.Spec

func (*CreateApigateway) Run 

func (cmd *CreateApigateway) Run(renv env.Running, params map[string]any) (any, error)

type CreateApigatewayroute 

type CreateApigatewayroute struct {
	API        *string `awsName:"ApiId" awsType:"awsstr" templateName:"api"`
	RouteKey   *string `awsName:"RouteKey" awsType:"awsstr" templateName:"route-key"`
	Target     *string `awsName:"Target" awsType:"awsstr" templateName:"target"`
	Authorizer *string `awsName:"AuthorizerId" awsType:"awsstr" templateName:"authorizer"`
	AuthType   *string `awsName:"AuthorizationType" awsType:"awsstr" templateName:"auth-type"`
	// contains filtered or unexported fields
}

func NewCreateApigatewayroute 

func NewCreateApigatewayroute(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateApigatewayroute

func (*CreateApigatewayroute) ExtractResult 

func (cmd *CreateApigatewayroute) ExtractResult(i any) string

func (*CreateApigatewayroute) ParamsSpec 

func (cmd *CreateApigatewayroute) ParamsSpec() params.Spec

func (*CreateApigatewayroute) Run 

func (cmd *CreateApigatewayroute) Run(renv env.Running, params map[string]any) (any, error)

type CreateApigatewaystage 

type CreateApigatewaystage struct {
	API        *string `awsName:"ApiId" awsType:"awsstr" templateName:"api"`
	Name       *string `awsName:"StageName" awsType:"awsstr" templateName:"name"`
	Autodeploy *bool   `awsName:"AutoDeploy" awsType:"awsbool" templateName:"autodeploy"`
	Deployment *string `awsName:"DeploymentId" awsType:"awsstr" templateName:"deployment"`
	Descr      *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCreateApigatewaystage 

func NewCreateApigatewaystage(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateApigatewaystage

func (*CreateApigatewaystage) ExtractResult 

func (cmd *CreateApigatewaystage) ExtractResult(i any) string

func (*CreateApigatewaystage) ParamsSpec 

func (cmd *CreateApigatewaystage) ParamsSpec() params.Spec

func (*CreateApigatewaystage) Run 

func (cmd *CreateApigatewaystage) Run(renv env.Running, params map[string]any) (any, error)

type CreateApplication added in v1.2.0 

type CreateApplication struct {
	Name        *string `awsName:"ApplicationName" awsType:"awsstr" templateName:"name"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCreateApplication added in v1.2.0 

func NewCreateApplication(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateApplication

func (*CreateApplication) ExtractResult added in v1.2.0 

func (cmd *CreateApplication) ExtractResult(i any) string

func (*CreateApplication) ParamsSpec added in v1.2.0 

func (cmd *CreateApplication) ParamsSpec() params.Spec

func (*CreateApplication) Run added in v1.2.0 

func (cmd *CreateApplication) Run(renv env.Running, params map[string]any) (any, error)

type CreateAppscalingpolicy 

type CreateAppscalingpolicy struct {
	Name                              *string   `awsName:"PolicyName" awsType:"awsstr" templateName:"name"`
	Type                              *string   `awsName:"PolicyType" awsType:"awsstr" templateName:"type"`
	Resource                          *string   `awsName:"ResourceId" awsType:"awsstr" templateName:"resource"`
	Dimension                         *string   `awsName:"ScalableDimension" awsType:"awsstr" templateName:"dimension"`
	ServiceNamespace                  *string   `awsName:"ServiceNamespace" awsType:"awsstr" templateName:"service-namespace"`
	StepscalingAdjustmentType         *string   `awsName:"StepScalingPolicyConfiguration.AdjustmentType" awsType:"awsstr" templateName:"stepscaling-adjustment-type"`
	StepscalingAdjustments            []*string `awsName:"StepScalingPolicyConfiguration.StepAdjustments" awsType:"awsstepadjustments" templateName:"stepscaling-adjustments"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateAppscalingpolicy

func (*CreateAppscalingpolicy) ExtractResult 

func (cmd *CreateAppscalingpolicy) ExtractResult(i any) string

func (*CreateAppscalingpolicy) ParamsSpec 

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

func (*CreateAppscalingpolicy) Run 

func (cmd *CreateAppscalingpolicy) Run(renv env.Running, params map[string]any) (any, error)

type CreateAppscalingtarget 

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

func NewCreateAppscalingtarget 

func NewCreateAppscalingtarget(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateAppscalingtarget

func (*CreateAppscalingtarget) ParamsSpec 

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

func (*CreateAppscalingtarget) Run 

func (cmd *CreateAppscalingtarget) Run(renv env.Running, params map[string]any) (any, error)

type CreateBackupplan added in v1.2.0 

type CreateBackupplan struct {

	// The plan carries its own name, so there is no separate name param to contradict it.
	DefinitionFile *string `awsName:"BackupPlan" awsType:"awsfiletostruct" templateName:"definition-file"`
	// contains filtered or unexported fields
}

func NewCreateBackupplan added in v1.2.0 

func NewCreateBackupplan(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateBackupplan

func (*CreateBackupplan) ExtractResult added in v1.2.0 

func (cmd *CreateBackupplan) ExtractResult(i any) string

func (*CreateBackupplan) ParamsSpec added in v1.2.0 

func (cmd *CreateBackupplan) ParamsSpec() params.Spec

func (*CreateBackupplan) Run added in v1.2.0 

func (cmd *CreateBackupplan) Run(renv env.Running, params map[string]any) (any, error)

type CreateBackupvault added in v1.2.0 

type CreateBackupvault struct {
	Name *string `awsName:"BackupVaultName" awsType:"awsstr" templateName:"name"`
	// Without a key the vault uses the AWS-managed one. A customer-managed key is what
	// makes a cross-account or cross-region copy possible.
	KmsKey *string `awsName:"EncryptionKeyArn" awsType:"awsstr" templateName:"kms-key"`
	// contains filtered or unexported fields
}

func NewCreateBackupvault added in v1.2.0 

func NewCreateBackupvault(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateBackupvault

func (*CreateBackupvault) ExtractResult added in v1.2.0 

func (cmd *CreateBackupvault) ExtractResult(i any) string

func (*CreateBackupvault) ParamsSpec added in v1.2.0 

func (cmd *CreateBackupvault) ParamsSpec() params.Spec

func (*CreateBackupvault) Run added in v1.2.0 

func (cmd *CreateBackupvault) Run(renv env.Running, params map[string]any) (any, error)

type CreateBroker added in v1.2.0 

type CreateBroker struct {
	Name   *string `awsName:"BrokerName" awsType:"awsstr" templateName:"name"`
	Engine *string `awsName:"EngineType" awsType:"awsstr" templateName:"engine"`
	Type   *string `awsName:"HostInstanceType" awsType:"awsstr" templateName:"type"`
	// SINGLE_INSTANCE or one of the active/standby and cluster modes. It decides both the
	// cost and whether the broker survives losing an availability zone, and the number of
	// subnets required depends on it, so there is no safe default.
	Mode           *string   `awsName:"DeploymentMode" awsType:"awsstr" templateName:"mode"`
	EngineVersion  *string   `awsName:"EngineVersion" awsType:"awsstr" templateName:"engine-version"`
	Subnets        []*string `awsName:"SubnetIds" awsType:"awsstringslice" templateName:"subnets"`
	Securitygroups []*string `awsName:"SecurityGroups" awsType:"awsstringslice" templateName:"securitygroups"`
	// Required by the API and security-relevant: a publicly accessible broker is
	// reachable from the internet.
	Public *bool `awsName:"PubliclyAccessible" awsType:"awsbool" templateName:"public"`
	// The initial user's credentials. A document because a broker takes a list of users
	// with per-user console access and group membership, and because putting a password on
	// the command line would also put it in the template log.
	UsersFile *string `awsName:"Users" awsType:"awsfiletostruct" templateName:"users-file"`
	// contains filtered or unexported fields
}

func NewCreateBroker added in v1.2.0 

func NewCreateBroker(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateBroker

func (*CreateBroker) ExtractResult added in v1.2.0 

func (cmd *CreateBroker) ExtractResult(i any) string

func (*CreateBroker) ParamsSpec added in v1.2.0 

func (cmd *CreateBroker) ParamsSpec() params.Spec

func (*CreateBroker) Run added in v1.2.0 

func (cmd *CreateBroker) Run(renv env.Running, params map[string]any) (any, error)

type CreateBucket 

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

func NewCreateBucket 

func NewCreateBucket(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateBucket

func (*CreateBucket) ExtractResult 

func (cmd *CreateBucket) ExtractResult(i any) string

func (*CreateBucket) ParamsSpec 

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

func (*CreateBucket) Run 

func (cmd *CreateBucket) Run(renv env.Running, params map[string]any) (any, error)

type CreateBuildproject added in v1.2.0 

type CreateBuildproject struct {
	Name           *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Role           *string `awsName:"ServiceRole" awsType:"awsstr" templateName:"role"`
	Description    *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	SourceType     *string `awsName:"Source.Type" awsType:"awsstr" templateName:"source-type"`
	SourceLocation *string `awsName:"Source.Location" awsType:"awsstr" templateName:"source-location"`
	Buildspec      *string `awsName:"Source.Buildspec" awsType:"awsstr" templateName:"buildspec"`
	// The environment defaults reflect what most projects use: a Linux container on
	// the standard managed image. Compute type has no safe default because it decides
	// the bill, so it is suggested rather than assumed.
	EnvType      *string `awsName:"Environment.Type" awsType:"awsstr" templateName:"env-type"`
	Image        *string `awsName:"Environment.Image" awsType:"awsstr" templateName:"image"`
	ComputeType  *string `awsName:"Environment.ComputeType" awsType:"awsstr" templateName:"compute-type"`
	ArtifactType *string `awsName:"Artifacts.Type" awsType:"awsstr" templateName:"artifact-type"`
	Timeout      *int64  `awsName:"TimeoutInMinutes" awsType:"awsint64" templateName:"timeout"`
	// contains filtered or unexported fields
}

CreateProject nests source, environment and artifacts in their own structs, which dotted awsName paths reach; the setter builds the intermediates. All three are required by AWS, so their type fields are required here rather than optional.

func NewCreateBuildproject added in v1.2.0 

func NewCreateBuildproject(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateBuildproject

func (*CreateBuildproject) ExtractResult added in v1.2.0 

func (cmd *CreateBuildproject) ExtractResult(i any) string

func (*CreateBuildproject) ParamsSpec added in v1.2.0 

func (cmd *CreateBuildproject) ParamsSpec() params.Spec

func (*CreateBuildproject) Run added in v1.2.0 

func (cmd *CreateBuildproject) Run(renv env.Running, params map[string]any) (any, error)

type CreateCachecluster added in v1.2.0 

type CreateCachecluster struct {
	ID                *string   `awsName:"CacheClusterId" awsType:"awsstr" templateName:"id"`
	Engine            *string   `awsName:"Engine" awsType:"awsstr" templateName:"engine"`
	EngineVersion     *string   `awsName:"EngineVersion" awsType:"awsstr" templateName:"engine-version"`
	Type              *string   `awsName:"CacheNodeType" awsType:"awsstr" templateName:"type"`
	Nodes             *int64    `awsName:"NumCacheNodes" awsType:"awsint64" templateName:"nodes"`
	SubnetGroup       *string   `awsName:"CacheSubnetGroupName" awsType:"awsstr" templateName:"subnet-group"`
	Securitygroups    []*string `awsName:"SecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroups"`
	Port              *int64    `awsName:"Port" awsType:"awsint64" templateName:"port"`
	Zone              *string   `awsName:"PreferredAvailabilityZone" awsType:"awsstr" templateName:"zone"`
	ReplicationGroup  *string   `awsName:"ReplicationGroupId" awsType:"awsstr" templateName:"replication-group"`
	ParameterGroup    *string   `awsName:"CacheParameterGroupName" awsType:"awsstr" templateName:"parameter-group"`
	SnapshotRetention *int64    `awsName:"SnapshotRetentionLimit" awsType:"awsint64" templateName:"snapshot-retention"`
	// contains filtered or unexported fields
}

func NewCreateCachecluster added in v1.2.0 

func NewCreateCachecluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateCachecluster

func (*CreateCachecluster) ExtractResult added in v1.2.0 

func (cmd *CreateCachecluster) ExtractResult(i any) string

func (*CreateCachecluster) ParamsSpec added in v1.2.0 

func (cmd *CreateCachecluster) ParamsSpec() params.Spec

A cache cluster is created either standalone, which needs an engine and a node type, or as a read replica joining an existing replication group, which inherits both. Those two forms are mutually exclusive; AWS rejects engine and node-type overrides on a replication-group member.

The shared params sit above the OnlyOneOf rather than inside each branch. The param collector walks every branch, so anything repeated is listed twice in `-h`. The cost is that a param only meaningful to one form — `nodes` on a replica, say — is accepted here and rejected by AWS instead.

func (*CreateCachecluster) Run added in v1.2.0 

func (cmd *CreateCachecluster) Run(renv env.Running, params map[string]any) (any, error)

type CreateCachesubnetgroup added in v1.2.0 

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

func NewCreateCachesubnetgroup added in v1.2.0 

func NewCreateCachesubnetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateCachesubnetgroup

func (*CreateCachesubnetgroup) ExtractResult added in v1.2.0 

func (cmd *CreateCachesubnetgroup) ExtractResult(i any) string

func (*CreateCachesubnetgroup) ParamsSpec added in v1.2.0 

func (cmd *CreateCachesubnetgroup) ParamsSpec() params.Spec

func (*CreateCachesubnetgroup) Run added in v1.2.0 

func (cmd *CreateCachesubnetgroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateCertificate 

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

func NewCreateCertificate 

func NewCreateCertificate(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateCertificate

func (*CreateCertificate) ExtractResult 

func (cmd *CreateCertificate) ExtractResult(i any) string

func (*CreateCertificate) ManualRun 

func (cmd *CreateCertificate) ManualRun(renv env.Running) (any, error)

func (*CreateCertificate) ParamsSpec 

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

func (*CreateCertificate) Run 

func (cmd *CreateCertificate) Run(renv env.Running, params map[string]any) (any, error)

type CreateClassicLoadbalancer 

type CreateClassicLoadbalancer struct {
	Name                  *string   `awsName:"LoadBalancerName" awsType:"awsstr" templateName:"name"`
	AvailabilityZones     []*string `awsName:"AvailabilityZones" awsType:"awsstringslice" templateName:"zones"`
	Listeners             []*string `awsName:"Listeners" awsType:"awsclassicloadblisteners" templateName:"listeners"`
	Subnets               []*string `awsName:"Subnets" awsType:"awsstringslice" templateName:"subnets"`
	Securitygroups        []*string `awsName:"SecurityGroups" awsType:"awsstringslice" templateName:"securitygroups"`
	Scheme                *string   `awsName:"Scheme" awsType:"awsstr" templateName:"scheme"`
	Tags                  []*string `awsName:"Tags" awsType:"awstagslice" templateName:"tags"`
	HealthCheckPathToPing string    `awsType:"awsstr" templateName:"healthcheck-path"`
	// contains filtered or unexported fields
}

func NewCreateClassicLoadbalancer 

func NewCreateClassicLoadbalancer(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateClassicLoadbalancer

func (*CreateClassicLoadbalancer) AfterRun 

func (cmd *CreateClassicLoadbalancer) AfterRun(renv env.Running, output any) (err error)

func (*CreateClassicLoadbalancer) ExtractResult 

func (cmd *CreateClassicLoadbalancer) ExtractResult(i any) string

func (*CreateClassicLoadbalancer) ParamsSpec 

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

func (*CreateClassicLoadbalancer) Run 

func (cmd *CreateClassicLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type CreateConfigrule added in v1.2.0 

type CreateConfigrule struct {
	Name            *string `awsName:"ConfigRule.ConfigRuleName" awsType:"awsstr" templateName:"name"`
	Source          *string `awsName:"ConfigRule.Source.SourceIdentifier" awsType:"awsstr" templateName:"source"`
	Owner           *string `awsName:"ConfigRule.Source.Owner" awsType:"awsstr" templateName:"owner"`
	Description     *string `awsName:"ConfigRule.Description" awsType:"awsstr" templateName:"description"`
	InputParameters *string `awsName:"ConfigRule.InputParameters" awsType:"awsstr" templateName:"input-parameters"`
	Frequency       *string `awsName:"ConfigRule.MaximumExecutionFrequency" awsType:"awsstr" templateName:"frequency"`
	// Restricting a rule to one resource type is the difference between evaluating a
	// handful of resources and evaluating the whole account.
	ResourceTypes []*string `awsName:"ConfigRule.Scope.ComplianceResourceTypes" awsType:"awsstringslice" templateName:"resource-types"`
	// contains filtered or unexported fields
}

PutConfigRule wraps everything in a nested ConfigRule, so the awsName paths are dotted rather than flat. The setter creates the intermediate structs as it walks them.

`owner` defaults to AWS, which is the case worth optimizing for: an AWS-managed rule needs only its identifier, whereas a CUSTOM_LAMBDA rule needs a function ARN as the identifier and usually source details as well.

func NewCreateConfigrule added in v1.2.0 

func NewCreateConfigrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateConfigrule

func (*CreateConfigrule) ExtractResult added in v1.2.0 

func (cmd *CreateConfigrule) ExtractResult(i any) string

PutConfigRule has an empty response, and the name is what the graph and delete key on.

func (*CreateConfigrule) ParamsSpec added in v1.2.0 

func (cmd *CreateConfigrule) ParamsSpec() params.Spec

func (*CreateConfigrule) Run added in v1.2.0 

func (cmd *CreateConfigrule) Run(renv env.Running, params map[string]any) (any, error)

type CreateConfigurationset added in v1.2.0 

type CreateConfigurationset struct {
	Name *string `awsName:"ConfigurationSetName" awsType:"awsstr" templateName:"name"`
	// Sending, reputation, suppression and delivery options are each their own nested
	// structure, and which combination matters depends entirely on the setup, so they
	// come from files rather than being flattened into a wall of flags.
	SendingFile     *string `awsName:"SendingOptions" awsType:"awsfiletostruct" templateName:"sending-file"`
	DeliveryFile    *string `awsName:"DeliveryOptions" awsType:"awsfiletostruct" templateName:"delivery-file"`
	ReputationFile  *string `awsName:"ReputationOptions" awsType:"awsfiletostruct" templateName:"reputation-file"`
	SuppressionFile *string `awsName:"SuppressionOptions" awsType:"awsfiletostruct" templateName:"suppression-file"`
	// contains filtered or unexported fields
}

func NewCreateConfigurationset added in v1.2.0 

func NewCreateConfigurationset(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateConfigurationset

func (*CreateConfigurationset) ExtractResult added in v1.2.0 

func (cmd *CreateConfigurationset) ExtractResult(i any) string

func (*CreateConfigurationset) ParamsSpec added in v1.2.0 

func (cmd *CreateConfigurationset) ParamsSpec() params.Spec

func (*CreateConfigurationset) Run added in v1.2.0 

func (cmd *CreateConfigurationset) Run(renv env.Running, params map[string]any) (any, error)

type CreateContainercluster 

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

func NewCreateContainercluster 

func NewCreateContainercluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateContainercluster

func (*CreateContainercluster) ExtractResult 

func (cmd *CreateContainercluster) ExtractResult(i any) string

func (*CreateContainercluster) ParamsSpec 

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

func (*CreateContainercluster) Run 

func (cmd *CreateContainercluster) Run(renv env.Running, params map[string]any) (any, error)

type CreateCrawler added in v1.2.0 

type CreateCrawler struct {
	Name     *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Role     *string `awsName:"Role" awsType:"awsstr" templateName:"role"`
	Database *string `awsName:"DatabaseName" awsType:"awsstr" templateName:"database"`
	// What to crawl: S3 paths, JDBC connections, DynamoDB tables and more, each with a
	// different shape, so it is a document.
	TargetsFile *string `awsName:"Targets" awsType:"awsfiletostruct" templateName:"targets-file"`
	Schedule    *string `awsName:"Schedule" awsType:"awsstr" templateName:"schedule"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCreateCrawler added in v1.2.0 

func NewCreateCrawler(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateCrawler

func (*CreateCrawler) ExtractResult added in v1.2.0 

func (cmd *CreateCrawler) ExtractResult(i any) string

func (*CreateCrawler) ParamsSpec added in v1.2.0 

func (cmd *CreateCrawler) ParamsSpec() params.Spec

func (*CreateCrawler) Run added in v1.2.0 

func (cmd *CreateCrawler) Run(renv env.Running, params map[string]any) (any, error)

type CreateDatabase 

type CreateDatabase struct {

	// Required for DB
	Type     *string `awsName:"DBInstanceClass" awsType:"awsstr" templateName:"type"`
	ID       *string `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"id"`
	Engine   *string `awsName:"Engine" awsType:"awsstr" templateName:"engine"`
	Password *string `awsName:"MasterUserPassword" awsType:"awsstr" templateName:"password"`
	Username *string `awsName:"MasterUsername" awsType:"awsstr" templateName:"username"`
	Size     *int64  `awsName:"AllocatedStorage" awsType:"awsint64" templateName:"size"`

	// Required for read replica DB
	ReadReplicaSourceDB   *string `awsName:"SourceDBInstanceIdentifier" awsType:"awsstr" templateName:"replica-source"`
	ReadReplicaIdentifier *string `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"replica"`

	// Extras common to both replica DB and source DB
	Autoupgrade      *bool   `awsName:"AutoMinorVersionUpgrade" awsType:"awsbool" templateName:"autoupgrade"`
	Availabilityzone *string `awsName:"AvailabilityZone" awsType:"awsstr" templateName:"availabilityzone"`
	Subnetgroup      *string `awsName:"DBSubnetGroupName" awsType:"awsstr" templateName:"subnetgroup"`
	Iops             *int64  `awsName:"Iops" awsType:"awsint64" templateName:"iops"`
	Optiongroup      *string `awsName:"OptionGroupName" awsType:"awsstr" templateName:"optiongroup"`
	Port             *int64  `awsName:"Port" awsType:"awsint64" templateName:"port"`
	Public           *bool   `awsName:"PubliclyAccessible" awsType:"awsbool" templateName:"public"`
	Storagetype      *string `awsName:"StorageType" awsType:"awsstr" templateName:"storagetype"`

	// Extra only for DB
	Backupretention   *int64    `awsName:"BackupRetentionPeriod" awsType:"awsint64" templateName:"backupretention"`
	Backupwindow      *string   `awsName:"PreferredBackupWindow" awsType:"awsstr" templateName:"backupwindow"`
	Cluster           *string   `awsName:"DBClusterIdentifier" awsType:"awsstr" templateName:"cluster"`
	Dbname            *string   `awsName:"DBName" awsType:"awsstr" templateName:"dbname"`
	Dbsecuritygroups  []*string `awsName:"DBSecurityGroups" awsType:"awsstringslice" templateName:"dbsecuritygroups"`
	Domain            *string   `awsName:"Domain" awsType:"awsstr" templateName:"domain"`
	Encrypted         *bool     `awsName:"StorageEncrypted" awsType:"awsbool" templateName:"encrypted"`
	Iamrole           *string   `awsName:"DomainIAMRoleName" awsType:"awsstr" templateName:"iamrole"`
	License           *string   `awsName:"LicenseModel" awsType:"awsstr" templateName:"license"`
	Maintenancewindow *string   `awsName:"PreferredMaintenanceWindow" awsType:"awsstr" templateName:"maintenancewindow"`
	Multiaz           *bool     `awsName:"MultiAZ" awsType:"awsbool" templateName:"multiaz"`
	Parametergroup    *string   `awsName:"DBParameterGroupName" awsType:"awsstr" templateName:"parametergroup"`
	Timezone          *string   `awsName:"Timezone" awsType:"awsstr" templateName:"timezone"`
	Vpcsecuritygroups []*string `awsName:"VpcSecurityGroupIds" awsType:"awsstringslice" templateName:"vpcsecuritygroups"`
	Version           *string   `awsName:"EngineVersion" awsType:"awsstr" templateName:"version"`

	// Extra only for replica DB
	CopyTagsToSnapshot *string `awsName:"CopyTagsToSnapshot" awsType:"awsbool" templateName:"copytagstosnapshot"`
	// contains filtered or unexported fields
}

func NewCreateDatabase 

func NewCreateDatabase(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDatabase

func (*CreateDatabase) ExtractResult 

func (cmd *CreateDatabase) ExtractResult(i any) string

func (*CreateDatabase) ManualRun 

func (cmd *CreateDatabase) ManualRun(renv env.Running) (output any, err error)

func (*CreateDatabase) ParamsSpec 

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

func (*CreateDatabase) Run 

func (cmd *CreateDatabase) Run(renv env.Running, params map[string]any) (any, error)

type CreateDbsubnetgroup 

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

func NewCreateDbsubnetgroup 

func NewCreateDbsubnetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDbsubnetgroup

func (*CreateDbsubnetgroup) ExtractResult 

func (cmd *CreateDbsubnetgroup) ExtractResult(i any) string

func (*CreateDbsubnetgroup) ParamsSpec 

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

func (*CreateDbsubnetgroup) Run 

func (cmd *CreateDbsubnetgroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateDeployapplication added in v1.2.0 

type CreateDeployapplication struct {
	Name     *string `awsName:"ApplicationName" awsType:"awsstr" templateName:"name"`
	Platform *string `awsName:"ComputePlatform" awsType:"awsstr" templateName:"platform"`
	// contains filtered or unexported fields
}

The entity is deployapplication rather than application, which Elastic Beanstalk owns. Both are "applications" in their own service's language, and the template grammar has one flat namespace.

func NewCreateDeployapplication added in v1.2.0 

func NewCreateDeployapplication(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDeployapplication

func (*CreateDeployapplication) ExtractResult added in v1.2.0 

func (cmd *CreateDeployapplication) ExtractResult(i any) string

CreateApplication returns an id, but every other CodeDeploy call takes the name.

func (*CreateDeployapplication) ParamsSpec added in v1.2.0 

func (cmd *CreateDeployapplication) ParamsSpec() params.Spec

func (*CreateDeployapplication) Run added in v1.2.0 

func (cmd *CreateDeployapplication) Run(renv env.Running, params map[string]any) (any, error)

type CreateDeployment added in v1.2.0 

type CreateDeployment struct {
	Application *string `awsName:"ApplicationName" awsType:"awsstr" templateName:"application"`
	Group       *string `awsName:"DeploymentGroupName" awsType:"awsstr" templateName:"group"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	Config      *string `awsName:"DeploymentConfigName" awsType:"awsstr" templateName:"config"`
	// The revision says what to deploy — an S3 object, a GitHub commit, an ECS task
	// definition — and its shape differs per source, so it is a document.
	RevisionFile *string `awsName:"Revision" awsType:"awsfiletostruct" templateName:"revision-file"`
	// contains filtered or unexported fields
}

A deployment is an event rather than a resource: it is created, runs, and is done. It is not listed, because listing needs an application and group per call and what it returns is history.

func NewCreateDeployment added in v1.2.0 

func NewCreateDeployment(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDeployment

func (*CreateDeployment) ExtractResult added in v1.2.0 

func (cmd *CreateDeployment) ExtractResult(i any) string

func (*CreateDeployment) ParamsSpec added in v1.2.0 

func (cmd *CreateDeployment) ParamsSpec() params.Spec

func (*CreateDeployment) Run added in v1.2.0 

func (cmd *CreateDeployment) Run(renv env.Running, params map[string]any) (any, error)

type CreateDeploymentgroup added in v1.2.0 

type CreateDeploymentgroup struct {
	Name        *string   `awsName:"DeploymentGroupName" awsType:"awsstr" templateName:"name"`
	Application *string   `awsName:"ApplicationName" awsType:"awsstr" templateName:"application"`
	Role        *string   `awsName:"ServiceRoleArn" awsType:"awsstr" templateName:"role"`
	Config      *string   `awsName:"DeploymentConfigName" awsType:"awsstr" templateName:"config"`
	ScalingGrps []*string `awsName:"AutoScalingGroups" awsType:"awsstringslice" templateName:"scalinggroups"`
	// The targeting rules — EC2 tag filters, on-premises filters, ECS services — are
	// nested documents, so they come from a file rather than being flattened.
	Ec2FilterFile *string `awsName:"Ec2TagFilters" awsType:"awsfiletostruct" templateName:"ec2-filters-file"`
	StyleFile     *string `awsName:"DeploymentStyle" awsType:"awsfiletostruct" templateName:"style-file"`
	RollbackFile  *string `awsName:"AutoRollbackConfiguration" awsType:"awsfiletostruct" templateName:"rollback-file"`
	// contains filtered or unexported fields
}

func NewCreateDeploymentgroup added in v1.2.0 

func NewCreateDeploymentgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDeploymentgroup

func (*CreateDeploymentgroup) ExtractResult added in v1.2.0 

func (cmd *CreateDeploymentgroup) ExtractResult(i any) string

func (*CreateDeploymentgroup) ParamsSpec added in v1.2.0 

func (cmd *CreateDeploymentgroup) ParamsSpec() params.Spec

func (*CreateDeploymentgroup) Run added in v1.2.0 

func (cmd *CreateDeploymentgroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateDiscoveryservice added in v1.2.0 

type CreateDiscoveryservice struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Namespace   *string `awsName:"NamespaceId" awsType:"awsstr" templateName:"namespace"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// The DNS records the service registers and their TTLs, and the health check, are
	// nested structures, so they come from files.
	DNSFile         *string `awsName:"DnsConfig" awsType:"awsfiletostruct" templateName:"dns-file"`
	HealthCheckFile *string `awsName:"HealthCheckConfig" awsType:"awsfiletostruct" templateName:"healthcheck-file"`
	// contains filtered or unexported fields
}

func NewCreateDiscoveryservice added in v1.2.0 

func NewCreateDiscoveryservice(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDiscoveryservice

func (*CreateDiscoveryservice) ExtractResult added in v1.2.0 

func (cmd *CreateDiscoveryservice) ExtractResult(i any) string

func (*CreateDiscoveryservice) ParamsSpec added in v1.2.0 

func (cmd *CreateDiscoveryservice) ParamsSpec() params.Spec

func (*CreateDiscoveryservice) Run added in v1.2.0 

func (cmd *CreateDiscoveryservice) Run(renv env.Running, params map[string]any) (any, error)

type CreateDistribution 

type CreateDistribution struct {
	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"`
	HTTPSBehavior  *string   `templateName:"https-behavior"`
	OriginPath     *string   `templateName:"origin-path"`
	PriceClass     *string   `templateName:"price-class"`
	MinTTL         *int64    `templateName:"min-ttl"`
	// contains filtered or unexported fields
}

func NewCreateDistribution 

func NewCreateDistribution(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDistribution

func (*CreateDistribution) ExtractResult 

func (cmd *CreateDistribution) ExtractResult(i any) string

func (*CreateDistribution) ManualRun 

func (cmd *CreateDistribution) ManualRun(renv env.Running) (any, error)

func (*CreateDistribution) ParamsSpec 

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

func (*CreateDistribution) Run 

func (cmd *CreateDistribution) Run(renv env.Running, params map[string]any) (any, error)

type CreateDynamodbtable 

type CreateDynamodbtable struct {
	Name          *string `templateName:"name"`
	PartitionKey  *string `templateName:"partition-key"`
	PartitionType *string `templateName:"partition-type"`
	SortKey       *string `templateName:"sort-key"`
	SortType      *string `templateName:"sort-type"`
	BillingMode   *string `templateName:"billing-mode"`
	ReadCapacity  *int64  `templateName:"read-capacity"`
	WriteCapacity *int64  `templateName:"write-capacity"`
	// contains filtered or unexported fields
}

CreateDynamodbtable creates a table with a partition key and an optional sort key.

The API models the key schema and attribute definitions as parallel lists that have to agree, and billing mode determines whether throughput is required at all, so BeforeRun assembles the request rather than relying on field tags.

func NewCreateDynamodbtable 

func NewCreateDynamodbtable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateDynamodbtable

func (*CreateDynamodbtable) ExtractResult 

func (cmd *CreateDynamodbtable) ExtractResult(i any) string

func (*CreateDynamodbtable) ManualRun 

func (cmd *CreateDynamodbtable) ManualRun(renv env.Running) (any, error)

func (*CreateDynamodbtable) ParamsSpec 

func (cmd *CreateDynamodbtable) ParamsSpec() params.Spec

func (*CreateDynamodbtable) Run 

func (cmd *CreateDynamodbtable) Run(renv env.Running, params map[string]any) (any, error)

type CreateEkscluster 

type CreateEkscluster struct {
	Name              *string   `templateName:"name"`
	Role              *string   `templateName:"role"`
	Subnets           []*string `templateName:"subnets"`
	Securitygroups    []*string `templateName:"securitygroups"`
	Version           *string   `templateName:"version"`
	PublicAccess      *bool     `templateName:"public-access"`
	PrivateAccess     *bool     `templateName:"private-access"`
	PublicAccessCidrs []*string `templateName:"public-access-cidrs"`
	// contains filtered or unexported fields
}

CreateEkscluster creates a control plane. The VPC config is a nested struct, so the request is assembled here rather than through field tags.

Cluster creation is asynchronous and takes roughly ten minutes; this returns as soon as the API accepts the request. Use `awless show ekscluster <name>` to watch it reach ACTIVE.

func NewCreateEkscluster 

func NewCreateEkscluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateEkscluster

func (*CreateEkscluster) ExtractResult 

func (cmd *CreateEkscluster) ExtractResult(i any) string

func (*CreateEkscluster) ManualRun 

func (cmd *CreateEkscluster) ManualRun(renv env.Running) (any, error)

func (*CreateEkscluster) ParamsSpec 

func (cmd *CreateEkscluster) ParamsSpec() params.Spec

func (*CreateEkscluster) Run 

func (cmd *CreateEkscluster) Run(renv env.Running, params map[string]any) (any, error)

type CreateEksnodegroup 

type CreateEksnodegroup struct {
	Name         *string   `templateName:"name"`
	Cluster      *string   `templateName:"cluster"`
	Role         *string   `templateName:"role"`
	Subnets      []*string `templateName:"subnets"`
	InstanceType *string   `templateName:"instance-type"`
	MinSize      *int64    `templateName:"min-size"`
	MaxSize      *int64    `templateName:"max-size"`
	DesiredSize  *int64    `templateName:"desired-size"`
	DiskSize     *int64    `templateName:"disk-size"`
	AmiType      *string   `templateName:"ami-type"`
	// contains filtered or unexported fields
}

CreateEksnodegroup adds a managed node group to an existing cluster.

func NewCreateEksnodegroup 

func NewCreateEksnodegroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateEksnodegroup

func (*CreateEksnodegroup) ExtractResult 

func (cmd *CreateEksnodegroup) ExtractResult(i any) string

func (*CreateEksnodegroup) ManualRun 

func (cmd *CreateEksnodegroup) ManualRun(renv env.Running) (any, error)

func (*CreateEksnodegroup) ParamsSpec 

func (cmd *CreateEksnodegroup) ParamsSpec() params.Spec

func (*CreateEksnodegroup) Run 

func (cmd *CreateEksnodegroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateElasticip 

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

func NewCreateElasticip 

func NewCreateElasticip(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateElasticip

func (*CreateElasticip) ExtractResult 

func (cmd *CreateElasticip) ExtractResult(i any) string

func (*CreateElasticip) ParamsSpec 

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

func (*CreateElasticip) Run 

func (cmd *CreateElasticip) Run(renv env.Running, params map[string]any) (any, error)

type CreateEmailidentity added in v1.2.0 

type CreateEmailidentity struct {
	Name *string `awsName:"EmailIdentity" awsType:"awsstr" templateName:"name"`
	// Attaching a configuration set at creation is the only way to have it apply to the
	// identity's first sends.
	ConfigurationSet *string `awsName:"ConfigurationSetName" awsType:"awsstr" templateName:"configuration-set"`
	// contains filtered or unexported fields
}

An email identity is a domain or a single address that SES will send from. Creating one starts verification rather than completing it: a domain needs DNS records published, an address needs a link clicked, so the identity exists in a pending state until then.

func NewCreateEmailidentity added in v1.2.0 

func NewCreateEmailidentity(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateEmailidentity

func (*CreateEmailidentity) ExtractResult added in v1.2.0 

func (cmd *CreateEmailidentity) ExtractResult(i any) string

CreateEmailIdentity returns the verification status, not the name.

func (*CreateEmailidentity) ParamsSpec added in v1.2.0 

func (cmd *CreateEmailidentity) ParamsSpec() params.Spec

func (*CreateEmailidentity) Run added in v1.2.0 

func (cmd *CreateEmailidentity) Run(renv env.Running, params map[string]any) (any, error)

type CreateEnvironment added in v1.2.0 

type CreateEnvironment struct {
	Name *string `awsName:"EnvironmentName" awsType:"awsstr" templateName:"name"`
	App  *string `awsName:"ApplicationName" awsType:"awsstr" templateName:"application"`
	// A platform is given either as a solution stack name or as a platform ARN; the two
	// are alternative spellings of the same thing and AWS rejects both together.
	SolutionStack *string `awsName:"SolutionStackName" awsType:"awsstr" templateName:"solution-stack"`
	Platform      *string `awsName:"PlatformArn" awsType:"awsstr" templateName:"platform"`
	Template      *string `awsName:"TemplateName" awsType:"awsstr" templateName:"config-template"`
	Version       *string `awsName:"VersionLabel" awsType:"awsstr" templateName:"version"`
	Description   *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	CNAMEPrefix   *string `awsName:"CNAMEPrefix" awsType:"awsstr" templateName:"cname-prefix"`
	// contains filtered or unexported fields
}

func NewCreateEnvironment added in v1.2.0 

func NewCreateEnvironment(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateEnvironment

func (*CreateEnvironment) ExtractResult added in v1.2.0 

func (cmd *CreateEnvironment) ExtractResult(i any) string

func (*CreateEnvironment) ParamsSpec added in v1.2.0 

func (cmd *CreateEnvironment) ParamsSpec() params.Spec

func (*CreateEnvironment) Run added in v1.2.0 

func (cmd *CreateEnvironment) Run(renv env.Running, params map[string]any) (any, error)

type CreateEventbus added in v1.2.0 

type CreateEventbus struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// An event bus backed by a partner event source is created from that source's
	// name rather than as an empty custom bus.
	Source *string `awsName:"EventSourceName" awsType:"awsstr" templateName:"source"`
	KmsKey *string `awsName:"KmsKeyIdentifier" awsType:"awsstr" templateName:"kms-key"`
	// contains filtered or unexported fields
}

func NewCreateEventbus added in v1.2.0 

func NewCreateEventbus(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateEventbus

func (*CreateEventbus) ExtractResult added in v1.2.0 

func (cmd *CreateEventbus) ExtractResult(i any) string

CreateEventBus returns the bus ARN rather than its name, but the name is what the graph and the delete command key on.

func (*CreateEventbus) ParamsSpec added in v1.2.0 

func (cmd *CreateEventbus) ParamsSpec() params.Spec

func (*CreateEventbus) Run added in v1.2.0 

func (cmd *CreateEventbus) Run(renv env.Running, params map[string]any) (any, error)

type CreateEventrule added in v1.2.0 

type CreateEventrule struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	EventBus    *string `awsName:"EventBusName" awsType:"awsstr" templateName:"eventbus"`
	Pattern     *string `awsName:"EventPattern" awsType:"awsstr" templateName:"pattern"`
	Schedule    *string `awsName:"ScheduleExpression" awsType:"awsstr" templateName:"schedule"`
	Role        *string `awsName:"RoleArn" awsType:"awsstr" templateName:"role"`
	State       *string `awsName:"State" awsType:"awsstr" templateName:"state"`
	// contains filtered or unexported fields
}

PutRule both creates and updates, so create and update map to the same call. A rule needs either an event pattern or a schedule expression; AWS rejects a rule with neither, and the two are independent rather than exclusive.

func NewCreateEventrule added in v1.2.0 

func NewCreateEventrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateEventrule

func (*CreateEventrule) ExtractResult added in v1.2.0 

func (cmd *CreateEventrule) ExtractResult(i any) string

func (*CreateEventrule) ParamsSpec added in v1.2.0 

func (cmd *CreateEventrule) ParamsSpec() params.Spec

func (*CreateEventrule) Run added in v1.2.0 

func (cmd *CreateEventrule) Run(renv env.Running, params map[string]any) (any, error)

type CreateFilesystem 

type CreateFilesystem struct {
	Token           *string `awsName:"CreationToken" awsType:"awsstr" templateName:"token"`
	PerformanceMode *string `awsName:"PerformanceMode" awsType:"awsstr" templateName:"performance-mode"`
	ThroughputMode  *string `awsName:"ThroughputMode" awsType:"awsstr" templateName:"throughput-mode"`
	Encrypted       *bool   `awsName:"Encrypted" awsType:"awsbool" templateName:"encrypted"`
	KmsKey          *string `awsName:"KmsKeyId" awsType:"awsstr" templateName:"kms-key"`
	// contains filtered or unexported fields
}

func NewCreateFilesystem 

func NewCreateFilesystem(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateFilesystem

func (*CreateFilesystem) ExtractResult 

func (cmd *CreateFilesystem) ExtractResult(i any) string

func (*CreateFilesystem) ParamsSpec 

func (cmd *CreateFilesystem) ParamsSpec() params.Spec

func (*CreateFilesystem) Run 

func (cmd *CreateFilesystem) Run(renv env.Running, params map[string]any) (any, error)

type CreateFsxbackup added in v1.2.0 

type CreateFsxbackup struct {
	FileSystem *string `awsName:"FileSystemId" awsType:"awsstr" templateName:"filesystem"`
	// An ONTAP or OpenZFS backup is taken of a volume rather than the whole file system,
	// so one or the other is given.
	Volume *string `awsName:"VolumeId" awsType:"awsstr" templateName:"volume"`
	// contains filtered or unexported fields
}

func NewCreateFsxbackup added in v1.2.0 

func NewCreateFsxbackup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateFsxbackup

func (*CreateFsxbackup) ExtractResult added in v1.2.0 

func (cmd *CreateFsxbackup) ExtractResult(i any) string

func (*CreateFsxbackup) ParamsSpec added in v1.2.0 

func (cmd *CreateFsxbackup) ParamsSpec() params.Spec

func (*CreateFsxbackup) Run added in v1.2.0 

func (cmd *CreateFsxbackup) Run(renv env.Running, params map[string]any) (any, error)

type CreateFsxfilesystem added in v1.2.0 

type CreateFsxfilesystem struct {
	Type           *string   `awsName:"FileSystemType" awsType:"awsstr" templateName:"type"`
	Capacity       *int64    `awsName:"StorageCapacity" awsType:"awsint64" templateName:"capacity"`
	Subnets        []*string `awsName:"SubnetIds" awsType:"awsstringslice" templateName:"subnets"`
	Securitygroups []*string `awsName:"SecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroups"`
	StorageType    *string   `awsName:"StorageType" awsType:"awsstr" templateName:"storage-type"`
	KmsKey         *string   `awsName:"KmsKeyId" awsType:"awsstr" templateName:"kms-key"`
	// Exactly one of these applies, chosen by the type above.
	WindowsFile *string `awsName:"WindowsConfiguration" awsType:"awsfiletostruct" templateName:"windows-file"`
	LustreFile  *string `awsName:"LustreConfiguration" awsType:"awsfiletostruct" templateName:"lustre-file"`
	OntapFile   *string `awsName:"OntapConfiguration" awsType:"awsfiletostruct" templateName:"ontap-file"`
	OpenZFSFile *string `awsName:"OpenZFSConfiguration" awsType:"awsfiletostruct" templateName:"openzfs-file"`
	// contains filtered or unexported fields
}

The entity is fsxfilesystem: EFS already owns "filesystem", and the two are different products that would be genuinely confusing to conflate.

FSx is really four file systems behind one API — Windows, Lustre, ONTAP and OpenZFS — each with its own configuration block and none of them interchangeable. The per-type settings therefore come from a file rather than being flattened into flags that only apply to one type.

func NewCreateFsxfilesystem added in v1.2.0 

func NewCreateFsxfilesystem(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateFsxfilesystem

func (*CreateFsxfilesystem) ExtractResult added in v1.2.0 

func (cmd *CreateFsxfilesystem) ExtractResult(i any) string

func (*CreateFsxfilesystem) ParamsSpec added in v1.2.0 

func (cmd *CreateFsxfilesystem) ParamsSpec() params.Spec

The four configuration files are mutually exclusive: passing the Lustre block for a Windows file system is rejected, and passing two is meaningless.

func (*CreateFsxfilesystem) Run added in v1.2.0 

func (cmd *CreateFsxfilesystem) Run(renv env.Running, params map[string]any) (any, error)

type CreateFunction 

type CreateFunction struct {
	Name          *string `awsName:"FunctionName" awsType:"awsstr" templateName:"name"`
	Handler       *string `awsName:"Handler" awsType:"awsstr" templateName:"handler"`
	Role          *string `awsName:"Role" awsType:"awsstr" templateName:"role"`
	Runtime       *string `awsName:"Runtime" awsType:"awsstr" templateName:"runtime"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateFunction

func (*CreateFunction) ExtractResult 

func (cmd *CreateFunction) ExtractResult(i any) string

func (*CreateFunction) ParamsSpec 

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

func (*CreateFunction) Run 

func (cmd *CreateFunction) Run(renv env.Running, params map[string]any) (any, error)

type CreateGluedatabase added in v1.2.0 

type CreateGluedatabase struct {
	Name        *string `awsName:"DatabaseInput.Name" awsType:"awsstr" templateName:"name"`
	Description *string `awsName:"DatabaseInput.Description" awsType:"awsstr" templateName:"description"`
	Location    *string `awsName:"DatabaseInput.LocationUri" awsType:"awsstr" templateName:"location"`
	// contains filtered or unexported fields
}

func NewCreateGluedatabase added in v1.2.0 

func NewCreateGluedatabase(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateGluedatabase

func (*CreateGluedatabase) ExtractResult added in v1.2.0 

func (cmd *CreateGluedatabase) ExtractResult(i any) string

func (*CreateGluedatabase) ParamsSpec added in v1.2.0 

func (cmd *CreateGluedatabase) ParamsSpec() params.Spec

func (*CreateGluedatabase) Run added in v1.2.0 

func (cmd *CreateGluedatabase) Run(renv env.Running, params map[string]any) (any, error)

type CreateGroup 

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

func NewCreateGroup 

func NewCreateGroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateGroup

func (*CreateGroup) ExtractResult 

func (cmd *CreateGroup) ExtractResult(i any) string

func (*CreateGroup) ParamsSpec 

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

func (*CreateGroup) Run 

func (cmd *CreateGroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateIdentitypool added in v1.2.0 

type CreateIdentitypool struct {
	Name *string `awsName:"IdentityPoolName" awsType:"awsstr" templateName:"name"`
	// Required by the API and security-relevant: unauthenticated identities hand AWS
	// credentials to anyone who asks, so there is no safe default to pick.
	AllowUnauthenticated *bool   `awsName:"AllowUnauthenticatedIdentities" awsType:"awsbool" templateName:"allow-unauthenticated"`
	DeveloperProvider    *string `awsName:"DeveloperProviderName" awsType:"awsstr" templateName:"developer-provider"`
	AllowClassicFlow     *bool   `awsName:"AllowClassicFlow" awsType:"awsbool" templateName:"allow-classic-flow"`
	// contains filtered or unexported fields
}

func NewCreateIdentitypool added in v1.2.0 

func NewCreateIdentitypool(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateIdentitypool

func (*CreateIdentitypool) ExtractResult added in v1.2.0 

func (cmd *CreateIdentitypool) ExtractResult(i any) string

func (*CreateIdentitypool) ParamsSpec added in v1.2.0 

func (cmd *CreateIdentitypool) ParamsSpec() params.Spec

func (*CreateIdentitypool) Run added in v1.2.0 

func (cmd *CreateIdentitypool) Run(renv env.Running, params map[string]any) (any, error)

type CreateImage 

type CreateImage struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Instance    *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance"`
	Reboot      *bool   `awsName:"NoReboot" awsType:"awsbool" templateName:"reboot"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCreateImage 

func NewCreateImage(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateImage

func (*CreateImage) BeforeRun 

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

func (*CreateImage) ExtractResult 

func (cmd *CreateImage) ExtractResult(i any) string

func (*CreateImage) ParamsSpec 

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

func (*CreateImage) Run 

func (cmd *CreateImage) Run(renv env.Running, params map[string]any) (any, error)

type CreateInstance 

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

func NewCreateInstance 

func NewCreateInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateInstance

func (*CreateInstance) AfterRun 

func (cmd *CreateInstance) AfterRun(renv env.Running, output any) error

func (*CreateInstance) ExtractResult 

func (cmd *CreateInstance) ExtractResult(i any) string

func (*CreateInstance) ParamsSpec 

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

func (*CreateInstance) PostProcessInput 

func (cmd *CreateInstance) PostProcessInput(iface any)

PostProcessInput adjusts the RunInstancesInput when associate-public-ip is requested. Because AssociatePublicIpAddress must live inside NetworkInterfaces[0], SecurityGroupIds and SubnetId must also be moved there (AWS rejects mixing top-level and NetworkInterfaces for these fields).

func (*CreateInstance) Run 

func (cmd *CreateInstance) Run(renv env.Running, params map[string]any) (any, error)

type CreateInstanceprofile 

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

func NewCreateInstanceprofile 

func NewCreateInstanceprofile(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateInstanceprofile

func (*CreateInstanceprofile) ParamsSpec 

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

func (*CreateInstanceprofile) Run 

func (cmd *CreateInstanceprofile) Run(renv env.Running, params map[string]any) (any, error)

type CreateInternetgateway 

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

func NewCreateInternetgateway 

func NewCreateInternetgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateInternetgateway

func (*CreateInternetgateway) ExtractResult 

func (cmd *CreateInternetgateway) ExtractResult(i any) string

func (*CreateInternetgateway) ParamsSpec 

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

func (*CreateInternetgateway) Run 

func (cmd *CreateInternetgateway) Run(renv env.Running, params map[string]any) (any, error)

type CreateIpset added in v1.2.0 

type CreateIpset struct {
	Name        *string   `templateName:"name"`
	Addresses   []*string `templateName:"addresses"`
	Scope       *string   `templateName:"scope"`
	Description *string   `templateName:"description"`
	IPVersion   *string   `templateName:"ip-version"`
	// contains filtered or unexported fields
}

func NewCreateIpset added in v1.2.0 

func NewCreateIpset(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateIpset

func (*CreateIpset) ExtractResult added in v1.2.0 

func (cmd *CreateIpset) ExtractResult(i any) string

func (*CreateIpset) ManualRun added in v1.2.0 

func (cmd *CreateIpset) ManualRun(renv env.Running) (any, error)

Hand-built rather than driven by awsName tags: IPAddressVersion is an enum that has to be derived from the addresses when the user does not give it, since a set may not mix IPv4 and IPv6.

func (*CreateIpset) ParamsSpec added in v1.2.0 

func (cmd *CreateIpset) ParamsSpec() params.Spec

func (*CreateIpset) Run added in v1.2.0 

func (cmd *CreateIpset) Run(renv env.Running, params map[string]any) (any, error)

type CreateJob added in v1.2.0 

type CreateJob struct {
	Name *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Role *string `awsName:"Role" awsType:"awsstr" templateName:"role"`
	// The command says which runtime and script to use. Its three fields are flat
	// enough to spell out rather than needing a document.
	CommandName *string `awsName:"Command.Name" awsType:"awsstr" templateName:"command"`
	ScriptPath  *string `awsName:"Command.ScriptLocation" awsType:"awsstr" templateName:"script"`
	PythonVer   *string `awsName:"Command.PythonVersion" awsType:"awsstr" templateName:"python-version"`
	GlueVersion *string `awsName:"GlueVersion" awsType:"awsstr" templateName:"glue-version"`
	WorkerType  *string `awsName:"WorkerType" awsType:"awsstr" templateName:"worker-type"`
	Workers     *int64  `awsName:"NumberOfWorkers" awsType:"awsint64" templateName:"workers"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	MaxRetries  *int64  `awsName:"MaxRetries" awsType:"awsint64" templateName:"max-retries"`
	TimeoutMins *int64  `awsName:"Timeout" awsType:"awsint64" templateName:"timeout"`
	// contains filtered or unexported fields
}

func NewCreateJob added in v1.2.0 

func NewCreateJob(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateJob

func (*CreateJob) ExtractResult added in v1.2.0 

func (cmd *CreateJob) ExtractResult(i any) string

func (*CreateJob) ParamsSpec added in v1.2.0 

func (cmd *CreateJob) ParamsSpec() params.Spec

func (*CreateJob) Run added in v1.2.0 

func (cmd *CreateJob) Run(renv env.Running, params map[string]any) (any, error)

type CreateKafkacluster added in v1.2.0 

type CreateKafkacluster struct {
	Name    *string   `awsName:"ClusterName" awsType:"awsstr" templateName:"name"`
	Version *string   `awsName:"KafkaVersion" awsType:"awsstr" templateName:"version"`
	Brokers *int64    `awsName:"NumberOfBrokerNodes" awsType:"awsint64" templateName:"brokers"`
	Subnets []*string `awsName:"BrokerNodeGroupInfo.ClientSubnets" awsType:"awsstringslice" templateName:"subnets"`
	Type    *string   `awsName:"BrokerNodeGroupInfo.InstanceType" awsType:"awsstr" templateName:"type"`
	// Security groups and storage sit inside the broker node group alongside the subnets.
	Securitygroups []*string `awsName:"BrokerNodeGroupInfo.SecurityGroups" awsType:"awsstringslice" templateName:"securitygroups"`
	StorageGB      *int64    `awsName:"BrokerNodeGroupInfo.StorageInfo.EbsStorageInfo.VolumeSize" awsType:"awsint64" templateName:"storage"`
	// Encryption and client authentication are nested structures with several mutually
	// relevant options, so they come from files.
	EncryptionFile *string `awsName:"EncryptionInfo" awsType:"awsfiletostruct" templateName:"encryption-file"`
	AuthFile       *string `awsName:"ClientAuthentication" awsType:"awsfiletostruct" templateName:"auth-file"`
	// contains filtered or unexported fields
}

The entity is kafkacluster: "cluster" would be ambiguous next to ECS, EKS and Redshift, all of which already have their own.

func NewCreateKafkacluster added in v1.2.0 

func NewCreateKafkacluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateKafkacluster

func (*CreateKafkacluster) ExtractResult added in v1.2.0 

func (cmd *CreateKafkacluster) ExtractResult(i any) string

func (*CreateKafkacluster) ParamsSpec added in v1.2.0 

func (cmd *CreateKafkacluster) ParamsSpec() params.Spec

The broker count must be a multiple of the number of subnets, which AWS enforces; there is nothing useful awless can default it to.

func (*CreateKafkacluster) Run added in v1.2.0 

func (cmd *CreateKafkacluster) Run(renv env.Running, params map[string]any) (any, error)

type CreateKeypair 

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

func NewCreateKeypair 

func NewCreateKeypair(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateKeypair

func (*CreateKeypair) BeforeRun 

func (cmd *CreateKeypair) BeforeRun(renv env.Running) error

func (*CreateKeypair) ExtractResult 

func (cmd *CreateKeypair) ExtractResult(i any) string

func (*CreateKeypair) ParamsSpec 

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

func (*CreateKeypair) Run 

func (cmd *CreateKeypair) Run(renv env.Running, params map[string]any) (any, error)

type CreateLaunchconfiguration 

type CreateLaunchconfiguration struct {
	Image          *string   `awsName:"ImageId" awsType:"awsstr" templateName:"image"`
	Type           *string   `awsName:"InstanceType" awsType:"awsstr" templateName:"type"`
	Name           *string   `awsName:"LaunchConfigurationName" awsType:"awsstr" templateName:"name"`
	Public         *bool     `awsName:"AssociatePublicIpAddress" awsType:"awsbool" templateName:"public"`
	Keypair        *string   `awsName:"KeyName" awsType:"awsstr" templateName:"keypair"`
	Userdata       *string   `awsName:"UserData" awsType:"awsuserdatatobase64" 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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateLaunchconfiguration

func (*CreateLaunchconfiguration) ExtractResult 

func (cmd *CreateLaunchconfiguration) ExtractResult(i any) string

func (*CreateLaunchconfiguration) ParamsSpec 

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

func (*CreateLaunchconfiguration) Run 

func (cmd *CreateLaunchconfiguration) Run(renv env.Running, params map[string]any) (any, error)

type CreateListener 

type CreateListener struct {
	Actiontype   *string `awsName:"DefaultActions[0]Type" awsType:"awsslicestruct" templateName:"actiontype"`
	Targetgroup  *string `awsName:"DefaultActions[0]TargetGroupArn" awsType:"awsslicestruct" templateName:"targetgroup"`
	Loadbalancer *string `awsName:"LoadBalancerArn" awsType:"awsstr" templateName:"loadbalancer"`
	Port         *int64  `awsName:"Port" awsType:"awsint64" templateName:"port"`
	Protocol     *string `awsName:"Protocol" awsType:"awsstr" templateName:"protocol"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateListener

func (*CreateListener) ExtractResult 

func (cmd *CreateListener) ExtractResult(i any) string

func (*CreateListener) ParamsSpec 

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

func (*CreateListener) Run 

func (cmd *CreateListener) Run(renv env.Running, params map[string]any) (any, error)

type CreateLoadbalancer 

type CreateLoadbalancer struct {
	Name           *string   `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Subnets        []*string `awsName:"Subnets" awsType:"awsstringslice" templateName:"subnets"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateLoadbalancer

func (*CreateLoadbalancer) ExtractResult 

func (cmd *CreateLoadbalancer) ExtractResult(i any) string

func (*CreateLoadbalancer) ParamsSpec 

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

func (*CreateLoadbalancer) Run 

func (cmd *CreateLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type CreateLoggroup 

type CreateLoggroup struct {
	Name   *string `awsName:"LogGroupName" awsType:"awsstr" templateName:"name"`
	KmsKey *string `awsName:"KmsKeyId" awsType:"awsstr" templateName:"kms-key"`
	// contains filtered or unexported fields
}

func NewCreateLoggroup 

func NewCreateLoggroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateLoggroup

func (*CreateLoggroup) ExtractResult 

func (cmd *CreateLoggroup) ExtractResult(i any) string

ExtractResult returns the name, since CreateLogGroup has an empty output and the name is what the graph keys on.

func (*CreateLoggroup) ParamsSpec 

func (cmd *CreateLoggroup) ParamsSpec() params.Spec

func (*CreateLoggroup) Run 

func (cmd *CreateLoggroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateLoginprofile 

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

func NewCreateLoginprofile 

func NewCreateLoginprofile(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateLoginprofile

func (*CreateLoginprofile) ExtractResult 

func (cmd *CreateLoginprofile) ExtractResult(i any) string

func (*CreateLoginprofile) ParamsSpec 

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

func (*CreateLoginprofile) Run 

func (cmd *CreateLoginprofile) Run(renv env.Running, params map[string]any) (any, error)

type CreateMfadevice 

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

func NewCreateMfadevice 

func NewCreateMfadevice(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateMfadevice

func (*CreateMfadevice) ExtractResult 

func (cmd *CreateMfadevice) ExtractResult(i any) string

func (*CreateMfadevice) ManualRun 

func (cmd *CreateMfadevice) ManualRun(renv env.Running) (any, error)

func (*CreateMfadevice) ParamsSpec 

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

func (*CreateMfadevice) Run 

func (cmd *CreateMfadevice) Run(renv env.Running, params map[string]any) (any, error)

type CreateNamespace added in v1.2.0 

type CreateNamespace struct {
	Name        *string `templateName:"name"`
	Description *string `templateName:"description"`
	// Given a VPC, the namespace is backed by a private hosted zone and instances are
	// resolvable by DNS from inside it. Without one, discovery is HTTP-only through the
	// Cloud Map API.
	Vpc *string `templateName:"vpc"`
	// contains filtered or unexported fields
}

Cloud Map is service discovery: a namespace holds services, and a service holds instances.

The entity is discoveryservice rather than service. "service" is already overloaded here — ECS has containerservice, and awless itself calls its AWS integrations services — so a bare "service" would be ambiguous in a template.

A namespace is created either as HTTP-only or backed by private DNS in a VPC. Those are different API calls, so the vpc param chooses between them and creation goes through ManualRun.

func NewCreateNamespace added in v1.2.0 

func NewCreateNamespace(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateNamespace

func (*CreateNamespace) ExtractResult added in v1.2.0 

func (cmd *CreateNamespace) ExtractResult(i any) string

Both calls return an operation id rather than the namespace: creation is asynchronous, and the namespace does not exist yet when the call returns.

func (*CreateNamespace) ManualRun added in v1.2.0 

func (cmd *CreateNamespace) ManualRun(renv env.Running) (any, error)

func (*CreateNamespace) ParamsSpec added in v1.2.0 

func (cmd *CreateNamespace) ParamsSpec() params.Spec

func (*CreateNamespace) Run added in v1.2.0 

func (cmd *CreateNamespace) Run(renv env.Running, params map[string]any) (any, error)

type CreateNatgateway 

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

func NewCreateNatgateway 

func NewCreateNatgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateNatgateway

func (*CreateNatgateway) ExtractResult 

func (cmd *CreateNatgateway) ExtractResult(i any) string

func (*CreateNatgateway) ParamsSpec 

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

func (*CreateNatgateway) Run 

func (cmd *CreateNatgateway) Run(renv env.Running, params map[string]any) (any, error)

type CreateNetworkinterface 

type CreateNetworkinterface struct {
	Subnet         *string   `awsName:"SubnetId" awsType:"awsstr" templateName:"subnet"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateNetworkinterface

func (*CreateNetworkinterface) ExtractResult 

func (cmd *CreateNetworkinterface) ExtractResult(i any) string

func (*CreateNetworkinterface) ParamsSpec 

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

func (*CreateNetworkinterface) Run 

func (cmd *CreateNetworkinterface) Run(renv env.Running, params map[string]any) (any, error)

type CreatePipeline added in v1.2.0 

type CreatePipeline struct {

	// The declaration carries its own name, so there is no separate name param to
	// contradict it.
	DefinitionFile *string `awsName:"Pipeline" awsType:"awsfiletostruct" templateName:"definition-file"`
	// contains filtered or unexported fields
}

func NewCreatePipeline added in v1.2.0 

func NewCreatePipeline(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreatePipeline

func (*CreatePipeline) ExtractResult added in v1.2.0 

func (cmd *CreatePipeline) ExtractResult(i any) string

func (*CreatePipeline) ParamsSpec added in v1.2.0 

func (cmd *CreatePipeline) ParamsSpec() params.Spec

func (*CreatePipeline) Run added in v1.2.0 

func (cmd *CreatePipeline) Run(renv env.Running, params map[string]any) (any, error)

type CreatePolicy 

type CreatePolicy struct {
	Name        *string   `awsName:"PolicyName" awsType:"awsstr" templateName:"name"`
	Effect      *string   `templateName:"effect"`
	Action      []*string `templateName:"action"`
	Resource    []*string `templateName:"resource"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreatePolicy

func (*CreatePolicy) BeforeRun 

func (cmd *CreatePolicy) BeforeRun(renv env.Running) error

func (*CreatePolicy) ExtractResult 

func (cmd *CreatePolicy) ExtractResult(i any) string

func (*CreatePolicy) ParamsSpec 

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

func (*CreatePolicy) Run 

func (cmd *CreatePolicy) Run(renv env.Running, params map[string]any) (any, error)

type CreateQueue 

type CreateQueue struct {
	Name              *string `awsName:"QueueName" awsType:"awsstr" templateName:"name"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateQueue

func (*CreateQueue) ExtractResult 

func (cmd *CreateQueue) ExtractResult(i any) string

func (*CreateQueue) ParamsSpec 

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

func (*CreateQueue) Run 

func (cmd *CreateQueue) Run(renv env.Running, params map[string]any) (any, error)

type CreateRecord 

type CreateRecord struct {
	Zone    *string   `templateName:"zone"`
	Name    *string   `templateName:"name"`
	Type    *string   `templateName:"type"`
	Values  []*string `templateName:"values"`
	TTL     *int64    `templateName:"ttl"`
	Comment *string   `templateName:"comment"`
	// contains filtered or unexported fields
}

func NewCreateRecord 

func NewCreateRecord(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRecord

func (*CreateRecord) ExtractResult 

func (cmd *CreateRecord) ExtractResult(i any) string

func (*CreateRecord) ManualRun 

func (cmd *CreateRecord) ManualRun(renv env.Running) (any, error)

func (*CreateRecord) ParamsSpec 

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

func (*CreateRecord) Run 

func (cmd *CreateRecord) Run(renv env.Running, params map[string]any) (any, error)

type CreateRedshiftcluster added in v1.2.0 

type CreateRedshiftcluster struct {
	ID       *string `awsName:"ClusterIdentifier" awsType:"awsstr" templateName:"id"`
	Username *string `awsName:"MasterUsername" awsType:"awsstr" templateName:"username"`
	Type     *string `awsName:"NodeType" awsType:"awsstr" templateName:"type"`
	Password *string `awsName:"MasterUserPassword" awsType:"awsstr" templateName:"password"`
	// Letting Redshift manage the credential in Secrets Manager avoids putting a
	// password on the command line, where it would also reach the template log.
	ManagePassword *bool     `awsName:"ManageMasterPassword" awsType:"awsbool" templateName:"manage-password"`
	Nodes          *int64    `awsName:"NumberOfNodes" awsType:"awsint64" templateName:"nodes"`
	ClusterType    *string   `awsName:"ClusterType" awsType:"awsstr" templateName:"cluster-type"`
	DBName         *string   `awsName:"DBName" awsType:"awsstr" templateName:"dbname"`
	SubnetGroup    *string   `awsName:"ClusterSubnetGroupName" awsType:"awsstr" templateName:"subnet-group"`
	Securitygroups []*string `awsName:"VpcSecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroups"`
	Public         *bool     `awsName:"PubliclyAccessible" awsType:"awsbool" templateName:"public"`
	Encrypted      *bool     `awsName:"Encrypted" awsType:"awsbool" templateName:"encrypted"`
	Zone           *string   `awsName:"AvailabilityZone" awsType:"awsstr" templateName:"zone"`
	// contains filtered or unexported fields
}

func NewCreateRedshiftcluster added in v1.2.0 

func NewCreateRedshiftcluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRedshiftcluster

func (*CreateRedshiftcluster) ExtractResult added in v1.2.0 

func (cmd *CreateRedshiftcluster) ExtractResult(i any) string

func (*CreateRedshiftcluster) ParamsSpec added in v1.2.0 

func (cmd *CreateRedshiftcluster) ParamsSpec() params.Spec

Exactly one of password and manage-password: AWS rejects both together, and with neither the call fails for want of a credential.

func (*CreateRedshiftcluster) Run added in v1.2.0 

func (cmd *CreateRedshiftcluster) Run(renv env.Running, params map[string]any) (any, error)

type CreateRedshiftsubnetgroup added in v1.2.0 

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

func NewCreateRedshiftsubnetgroup added in v1.2.0 

func NewCreateRedshiftsubnetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRedshiftsubnetgroup

func (*CreateRedshiftsubnetgroup) ExtractResult added in v1.2.0 

func (cmd *CreateRedshiftsubnetgroup) ExtractResult(i any) string

func (*CreateRedshiftsubnetgroup) ParamsSpec added in v1.2.0 

func (cmd *CreateRedshiftsubnetgroup) ParamsSpec() params.Spec

Description is required by the API rather than optional, unlike the equivalent on RDS and ElastiCache.

func (*CreateRedshiftsubnetgroup) Run added in v1.2.0 

func (cmd *CreateRedshiftsubnetgroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateReplicationgroup added in v1.2.0 

type CreateReplicationgroup struct {
	ID                *string   `awsName:"ReplicationGroupId" awsType:"awsstr" templateName:"id"`
	Description       *string   `awsName:"ReplicationGroupDescription" awsType:"awsstr" templateName:"description"`
	Engine            *string   `awsName:"Engine" awsType:"awsstr" templateName:"engine"`
	EngineVersion     *string   `awsName:"EngineVersion" awsType:"awsstr" templateName:"engine-version"`
	Type              *string   `awsName:"CacheNodeType" awsType:"awsstr" templateName:"type"`
	Replicas          *int64    `awsName:"NumCacheClusters" awsType:"awsint64" templateName:"clusters"`
	SubnetGroup       *string   `awsName:"CacheSubnetGroupName" awsType:"awsstr" templateName:"subnet-group"`
	Securitygroups    []*string `awsName:"SecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroups"`
	Port              *int64    `awsName:"Port" awsType:"awsint64" templateName:"port"`
	MultiAZ           *bool     `awsName:"MultiAZEnabled" awsType:"awsbool" templateName:"multi-az"`
	AutomaticFailover *bool     `awsName:"AutomaticFailoverEnabled" awsType:"awsbool" templateName:"automatic-failover"`
	AtRestEncryption  *bool     `awsName:"AtRestEncryptionEnabled" awsType:"awsbool" templateName:"at-rest-encryption"`
	TransitEncryption *bool     `awsName:"TransitEncryptionEnabled" awsType:"awsbool" templateName:"transit-encryption"`
	SnapshotRetention *int64    `awsName:"SnapshotRetentionLimit" awsType:"awsint64" templateName:"snapshot-retention"`
	// contains filtered or unexported fields
}

func NewCreateReplicationgroup added in v1.2.0 

func NewCreateReplicationgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateReplicationgroup

func (*CreateReplicationgroup) ExtractResult added in v1.2.0 

func (cmd *CreateReplicationgroup) ExtractResult(i any) string

func (*CreateReplicationgroup) ParamsSpec added in v1.2.0 

func (cmd *CreateReplicationgroup) ParamsSpec() params.Spec

func (*CreateReplicationgroup) Run added in v1.2.0 

func (cmd *CreateReplicationgroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateRepository 

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

func NewCreateRepository 

func NewCreateRepository(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRepository

func (*CreateRepository) ExtractResult 

func (cmd *CreateRepository) ExtractResult(i any) string

func (*CreateRepository) ParamsSpec 

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

func (*CreateRepository) Run 

func (cmd *CreateRepository) Run(renv env.Running, params map[string]any) (any, error)

type CreateRole 

type CreateRole struct {
	Name             *string   `awsName:"RoleName" awsType:"awsstr" templateName:"name" `
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRole

func (*CreateRole) ExtractResult 

func (cmd *CreateRole) ExtractResult(i any) string

func (*CreateRole) ManualRun 

func (cmd *CreateRole) ManualRun(renv env.Running) (any, error)

func (*CreateRole) ParamsSpec 

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

func (*CreateRole) Run 

func (cmd *CreateRole) Run(renv env.Running, params map[string]any) (any, error)

type CreateRoute 

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

func NewCreateRoute 

func NewCreateRoute(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRoute

func (*CreateRoute) ParamsSpec 

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

func (*CreateRoute) Run 

func (cmd *CreateRoute) Run(renv env.Running, params map[string]any) (any, error)

type CreateRoutetable 

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

func NewCreateRoutetable 

func NewCreateRoutetable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRoutetable

func (*CreateRoutetable) ExtractResult 

func (cmd *CreateRoutetable) ExtractResult(i any) string

func (*CreateRoutetable) ParamsSpec 

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

func (*CreateRoutetable) Run 

func (cmd *CreateRoutetable) Run(renv env.Running, params map[string]any) (any, error)

type CreateRulegroup added in v1.2.0 

type CreateRulegroup struct {
	Name  *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Scope *string `awsName:"Scope" awsType:"awsstr" templateName:"scope"`
	// Capacity is fixed at creation and cannot be raised later, so it is required
	// rather than guessed.
	Capacity       *int64  `awsName:"Capacity" awsType:"awsint64" templateName:"capacity"`
	VisibilityFile *string `awsName:"VisibilityConfig" awsType:"awsfiletostruct" templateName:"visibility-file"`
	RulesFile      *string `awsName:"Rules" awsType:"awsfiletostruct" templateName:"rules-file"`
	Description    *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewCreateRulegroup added in v1.2.0 

func NewCreateRulegroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateRulegroup

func (*CreateRulegroup) BeforeRun added in v1.2.0 

func (cmd *CreateRulegroup) BeforeRun(renv env.Running) error

func (*CreateRulegroup) ExtractResult added in v1.2.0 

func (cmd *CreateRulegroup) ExtractResult(i any) string

func (*CreateRulegroup) ParamsSpec added in v1.2.0 

func (cmd *CreateRulegroup) ParamsSpec() params.Spec

func (*CreateRulegroup) Run added in v1.2.0 

func (cmd *CreateRulegroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateS3object 

type CreateS3object struct {
	Bucket *string `awsName:"Bucket" awsType:"awsstr" templateName:"bucket"`
	File   *string `awsName:"Body" awsType:"awsstr" templateName:"file"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateS3object

func (*CreateS3object) ExtractResult 

func (cmd *CreateS3object) ExtractResult(i any) string

func (*CreateS3object) ManualRun 

func (cmd *CreateS3object) ManualRun(renv env.Running) (any, error)

func (*CreateS3object) ParamsSpec 

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

func (*CreateS3object) Run 

func (cmd *CreateS3object) Run(renv env.Running, params map[string]any) (any, error)

type CreateScalinggroup 

type CreateScalinggroup struct {
	Name                   *string   `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name"`
	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"`
	Subnets                []*string `awsName:"VPCZoneIdentifier" awsType:"awscsvstr" templateName:"subnets"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateScalinggroup

func (*CreateScalinggroup) ExtractResult 

func (cmd *CreateScalinggroup) ExtractResult(i any) string

func (*CreateScalinggroup) ParamsSpec 

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

func (*CreateScalinggroup) Run 

func (cmd *CreateScalinggroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateScalingpolicy 

type CreateScalingpolicy struct {
	AdjustmentType      *string `awsName:"AdjustmentType" awsType:"awsstr" templateName:"adjustment-type"`
	Scalinggroup        *string `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"scalinggroup"`
	Name                *string `awsName:"PolicyName" awsType:"awsstr" templateName:"name"`
	AdjustmentScaling   *int64  `awsName:"ScalingAdjustment" awsType:"awsint64" templateName:"adjustment-scaling"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateScalingpolicy

func (*CreateScalingpolicy) ExtractResult 

func (cmd *CreateScalingpolicy) ExtractResult(i any) string

func (*CreateScalingpolicy) ParamsSpec 

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

func (*CreateScalingpolicy) Run 

func (cmd *CreateScalingpolicy) Run(renv env.Running, params map[string]any) (any, error)

type CreateSecret 

type CreateSecret struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Secret      *string `awsName:"SecretString" awsType:"awsstr" templateName:"secret"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	KmsKey      *string `awsName:"KmsKeyId" awsType:"awsstr" templateName:"kms-key"`
	// contains filtered or unexported fields
}

func NewCreateSecret 

func NewCreateSecret(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateSecret

func (*CreateSecret) ExtractResult 

func (cmd *CreateSecret) ExtractResult(i any) string

func (*CreateSecret) ParamsSpec 

func (cmd *CreateSecret) ParamsSpec() params.Spec

func (*CreateSecret) Run 

func (cmd *CreateSecret) Run(renv env.Running, params map[string]any) (any, error)

type CreateSecuritygroup 

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

func NewCreateSecuritygroup 

func NewCreateSecuritygroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateSecuritygroup

func (*CreateSecuritygroup) ExtractResult 

func (cmd *CreateSecuritygroup) ExtractResult(i any) string

func (*CreateSecuritygroup) ParamsSpec 

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

func (*CreateSecuritygroup) Run 

func (cmd *CreateSecuritygroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateSnapshot 

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

func NewCreateSnapshot 

func NewCreateSnapshot(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateSnapshot

func (*CreateSnapshot) ExtractResult 

func (cmd *CreateSnapshot) ExtractResult(i any) string

func (*CreateSnapshot) ParamsSpec 

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

func (*CreateSnapshot) Run 

func (cmd *CreateSnapshot) Run(renv env.Running, params map[string]any) (any, error)

type CreateSsmparameter 

type CreateSsmparameter struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Value       *string `awsName:"Value" awsType:"awsstr" templateName:"value"`
	Type        *string `awsName:"Type" awsType:"awsstr" templateName:"type"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	KmsKey      *string `awsName:"KeyId" awsType:"awsstr" templateName:"kms-key"`
	Tier        *string `awsName:"Tier" awsType:"awsstr" templateName:"tier"`
	// contains filtered or unexported fields
}

CreateSsmparameter writes an SSM parameter. type defaults to String; use SecureString for values that should be KMS-encrypted at rest.

func NewCreateSsmparameter 

func NewCreateSsmparameter(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateSsmparameter

func (*CreateSsmparameter) ExtractResult 

func (cmd *CreateSsmparameter) ExtractResult(i any) string

func (*CreateSsmparameter) ParamsSpec 

func (cmd *CreateSsmparameter) ParamsSpec() params.Spec

func (*CreateSsmparameter) Run 

func (cmd *CreateSsmparameter) Run(renv env.Running, params map[string]any) (any, error)

type CreateStack 

type CreateStack struct {
	Name                  *string   `awsName:"StackName" awsType:"awsstr" templateName:"name"`
	TemplateFile          *string   `awsName:"TemplateBody" awsType:"awsfiletostring" templateName:"template-file"`
	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"`
	Tags                  []*string `awsName:"Tags" awsType:"awstagslice" templateName:"tags"`
	PolicyBody            *string   `awsName:"StackPolicyBody" awsType:"awsstr"`
	StackFile             *string   `templateName:"stack-file"`
	RollbackTriggers      []*string `awsName:"RollbackConfiguration.RollbackTriggers" awsType:"awsalarmrollbacktriggers" templateName:"rollback-triggers"`
	RollbackMonitoringMin *int64    `awsName:"RollbackConfiguration.MonitoringTimeInMinutes" awsType:"awsint64" templateName:"rollback-monitoring-min"`
	// contains filtered or unexported fields
}

func NewCreateStack 

func NewCreateStack(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateStack

func (*CreateStack) BeforeRun 

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

Add StackFile support via BeforeRun hook https://github.com/bootswithdefer/awless/issues/145 http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html

func (*CreateStack) ExtractResult 

func (cmd *CreateStack) ExtractResult(i any) string

func (*CreateStack) ParamsSpec 

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

func (*CreateStack) Run 

func (cmd *CreateStack) Run(renv env.Running, params map[string]any) (any, error)

type CreateStatemachine added in v1.2.0 

type CreateStatemachine struct {
	Name *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Role *string `awsName:"RoleArn" awsType:"awsstr" templateName:"role"`
	// The Amazon States Language document. Taken from a file because it is JSON of
	// non-trivial size, which the template grammar cannot carry inline without
	// single-quoting the whole thing.
	DefinitionFile *string `awsName:"Definition" awsType:"awsfiletostring" templateName:"definition-file"`
	Type           *string `awsName:"Type" awsType:"awsstr" templateName:"type"`
	Publish        *bool   `awsName:"Publish" awsType:"awsbool" templateName:"publish"`
	// contains filtered or unexported fields
}

func NewCreateStatemachine added in v1.2.0 

func NewCreateStatemachine(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateStatemachine

func (*CreateStatemachine) ExtractResult added in v1.2.0 

func (cmd *CreateStatemachine) ExtractResult(i any) string

func (*CreateStatemachine) ParamsSpec added in v1.2.0 

func (cmd *CreateStatemachine) ParamsSpec() params.Spec

func (*CreateStatemachine) Run added in v1.2.0 

func (cmd *CreateStatemachine) Run(renv env.Running, params map[string]any) (any, error)

type CreateStream added in v1.2.0 

type CreateStream struct {
	Name *string `awsName:"StreamName" awsType:"awsstr" templateName:"name"`
	// Shards apply to a PROVISIONED stream only; an ON_DEMAND stream scales itself and
	// AWS rejects a shard count alongside it.
	Shards *int64  `awsName:"ShardCount" awsType:"awsint64" templateName:"shards"`
	Mode   *string `awsName:"StreamModeDetails.StreamMode" awsType:"awsstr" templateName:"mode"`
	// contains filtered or unexported fields
}

func NewCreateStream added in v1.2.0 

func NewCreateStream(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateStream

func (*CreateStream) ExtractResult added in v1.2.0 

func (cmd *CreateStream) ExtractResult(i any) string

CreateStream returns nothing, and the name is what the graph and delete key on.

func (*CreateStream) ParamsSpec added in v1.2.0 

func (cmd *CreateStream) ParamsSpec() params.Spec

func (*CreateStream) Run added in v1.2.0 

func (cmd *CreateStream) Run(renv env.Running, params map[string]any) (any, error)

type CreateSubnet 

type CreateSubnet struct {
	CIDR             *string `awsName:"CidrBlock" awsType:"awsstr" templateName:"cidr"`
	VPC              *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateSubnet

func (*CreateSubnet) AfterRun 

func (cmd *CreateSubnet) AfterRun(renv env.Running, output any) error

func (*CreateSubnet) ExtractResult 

func (cmd *CreateSubnet) ExtractResult(i any) string

func (*CreateSubnet) ParamsSpec 

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

func (*CreateSubnet) Run 

func (cmd *CreateSubnet) Run(renv env.Running, params map[string]any) (any, error)

type CreateSubscription 

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

func NewCreateSubscription 

func NewCreateSubscription(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateSubscription

func (*CreateSubscription) ExtractResult 

func (cmd *CreateSubscription) ExtractResult(i any) string

func (*CreateSubscription) ParamsSpec 

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

func (*CreateSubscription) Run 

func (cmd *CreateSubscription) Run(renv env.Running, params map[string]any) (any, error)

type CreateTag 

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

func NewCreateTag 

func NewCreateTag(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateTag

func (*CreateTag) ManualRun 

func (cmd *CreateTag) ManualRun(renv env.Running) (any, error)

func (*CreateTag) ParamsSpec 

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

func (*CreateTag) Run 

func (cmd *CreateTag) Run(renv env.Running, params map[string]any) (any, error)

type CreateTargetgroup 

type CreateTargetgroup struct {
	Name                *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Port                *int64  `awsName:"Port" awsType:"awsint64" templateName:"port"`
	Protocol            *string `awsName:"Protocol" awsType:"awsstr" templateName:"protocol"`
	Vpc                 *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateTargetgroup

func (*CreateTargetgroup) ExtractResult 

func (cmd *CreateTargetgroup) ExtractResult(i any) string

func (*CreateTargetgroup) ParamsSpec 

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

func (*CreateTargetgroup) Run 

func (cmd *CreateTargetgroup) Run(renv env.Running, params map[string]any) (any, error)

type CreateTopic 

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

func NewCreateTopic 

func NewCreateTopic(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateTopic

func (*CreateTopic) ExtractResult 

func (cmd *CreateTopic) ExtractResult(i any) string

func (*CreateTopic) ParamsSpec 

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

func (*CreateTopic) Run 

func (cmd *CreateTopic) Run(renv env.Running, params map[string]any) (any, error)

type CreateTrail 

type CreateTrail struct {
	Name            *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Bucket          *string `awsName:"S3BucketName" awsType:"awsstr" templateName:"bucket"`
	Prefix          *string `awsName:"S3KeyPrefix" awsType:"awsstr" templateName:"prefix"`
	Multiregion     *bool   `awsName:"IsMultiRegionTrail" awsType:"awsbool" templateName:"multiregion"`
	Global          *bool   `awsName:"IncludeGlobalServiceEvents" awsType:"awsbool" templateName:"global-events"`
	LogValidation   *bool   `awsName:"EnableLogFileValidation" awsType:"awsbool" templateName:"log-validation"`
	KmsKey          *string `awsName:"KmsKeyId" awsType:"awsstr" templateName:"kms-key"`
	SnsTopic        *string `awsName:"SnsTopicName" awsType:"awsstr" templateName:"sns-topic"`
	OrganizationAll *bool   `awsName:"IsOrganizationTrail" awsType:"awsbool" templateName:"organization"`
	// contains filtered or unexported fields
}

func NewCreateTrail 

func NewCreateTrail(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateTrail

func (*CreateTrail) ExtractResult 

func (cmd *CreateTrail) ExtractResult(i any) string

func (*CreateTrail) ParamsSpec 

func (cmd *CreateTrail) ParamsSpec() params.Spec

func (*CreateTrail) Run 

func (cmd *CreateTrail) Run(renv env.Running, params map[string]any) (any, error)

type CreateTransitgateway added in v1.2.0 

type CreateTransitgateway struct {
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// The ASN is fixed at creation. Leaving it unset takes the AWS default of 64512.
	ASN *int64 `awsName:"Options.AmazonSideAsn" awsType:"awsint64" templateName:"asn"`
	// Automatic acceptance and automatic association are what make a transit gateway
	// convenient in a single account and dangerous across many, so they are explicit.
	AutoAccept      *string `awsName:"Options.AutoAcceptSharedAttachments" awsType:"awsstr" templateName:"auto-accept"`
	DefaultAssoc    *string `awsName:"Options.DefaultRouteTableAssociation" awsType:"awsstr" templateName:"default-association"`
	DefaultPropagat *string `awsName:"Options.DefaultRouteTablePropagation" awsType:"awsstr" templateName:"default-propagation"`
	DNSSupport      *string `awsName:"Options.DnsSupport" awsType:"awsstr" templateName:"dns-support"`
	// contains filtered or unexported fields
}

func NewCreateTransitgateway added in v1.2.0 

func NewCreateTransitgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateTransitgateway

func (*CreateTransitgateway) ExtractResult added in v1.2.0 

func (cmd *CreateTransitgateway) ExtractResult(i any) string

func (*CreateTransitgateway) ParamsSpec added in v1.2.0 

func (cmd *CreateTransitgateway) ParamsSpec() params.Spec

func (*CreateTransitgateway) Run added in v1.2.0 

func (cmd *CreateTransitgateway) Run(renv env.Running, params map[string]any) (any, error)

type CreateTransitgatewayattachment added in v1.2.0 

type CreateTransitgatewayattachment struct {
	Gateway *string   `awsName:"TransitGatewayId" awsType:"awsstr" templateName:"transitgateway"`
	Vpc     *string   `awsName:"VpcId" awsType:"awsstr" templateName:"vpc"`
	Subnets []*string `awsName:"SubnetIds" awsType:"awsstringslice" templateName:"subnets"`
	// contains filtered or unexported fields
}

An attachment joins a VPC to a transit gateway. It is a create rather than an attach because it is a resource with its own id and lifecycle, not a link between two existing things.

func NewCreateTransitgatewayattachment added in v1.2.0 

func NewCreateTransitgatewayattachment(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateTransitgatewayattachment

func (*CreateTransitgatewayattachment) ExtractResult added in v1.2.0 

func (cmd *CreateTransitgatewayattachment) ExtractResult(i any) string

func (*CreateTransitgatewayattachment) ParamsSpec added in v1.2.0 

func (cmd *CreateTransitgatewayattachment) ParamsSpec() params.Spec

One subnet per availability zone is what the gateway uses to reach the VPC, so subnets are required rather than defaulted.

func (*CreateTransitgatewayattachment) Run added in v1.2.0 

func (cmd *CreateTransitgatewayattachment) Run(renv env.Running, params map[string]any) (any, error)

type CreateTransitgatewayroutetable added in v1.2.0 

type CreateTransitgatewayroutetable struct {
	Gateway *string `awsName:"TransitGatewayId" awsType:"awsstr" templateName:"transitgateway"`
	// contains filtered or unexported fields
}

func NewCreateTransitgatewayroutetable added in v1.2.0 

func NewCreateTransitgatewayroutetable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateTransitgatewayroutetable

func (*CreateTransitgatewayroutetable) ExtractResult added in v1.2.0 

func (cmd *CreateTransitgatewayroutetable) ExtractResult(i any) string

func (*CreateTransitgatewayroutetable) ParamsSpec added in v1.2.0 

func (cmd *CreateTransitgatewayroutetable) ParamsSpec() params.Spec

func (*CreateTransitgatewayroutetable) Run added in v1.2.0 

func (cmd *CreateTransitgatewayroutetable) Run(renv env.Running, params map[string]any) (any, error)

type CreateUser 

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

func NewCreateUser 

func NewCreateUser(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateUser

func (*CreateUser) ExtractResult 

func (cmd *CreateUser) ExtractResult(i any) string

func (*CreateUser) ParamsSpec 

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

func (*CreateUser) Run 

func (cmd *CreateUser) Run(renv env.Running, params map[string]any) (any, error)

type CreateUserpool added in v1.2.0 

type CreateUserpool struct {
	Name *string `awsName:"PoolName" awsType:"awsstr" templateName:"name"`
	// Deletion protection defaults to active on a new pool in the console but not in the
	// API, and a user pool holds credentials that cannot be recreated, so it is worth
	// surfacing.
	DeletionProtection *string   `awsName:"DeletionProtection" awsType:"awsstr" templateName:"deletion-protection"`
	AutoVerified       []*string `awsName:"AutoVerifiedAttributes" awsType:"awsstringslice" templateName:"auto-verified"`
	AliasAttributes    []*string `awsName:"AliasAttributes" awsType:"awsstringslice" templateName:"alias-attributes"`
	// The password policy, MFA settings and recovery options are nested structures whose
	// shape depends on the setup, so they come from files.
	PoliciesFile *string `awsName:"Policies" awsType:"awsfiletostruct" templateName:"policies-file"`
	RecoveryFile *string `awsName:"AccountRecoverySetting" awsType:"awsfiletostruct" templateName:"recovery-file"`
	// contains filtered or unexported fields
}

func NewCreateUserpool added in v1.2.0 

func NewCreateUserpool(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateUserpool

func (*CreateUserpool) ExtractResult added in v1.2.0 

func (cmd *CreateUserpool) ExtractResult(i any) string

func (*CreateUserpool) ParamsSpec added in v1.2.0 

func (cmd *CreateUserpool) ParamsSpec() params.Spec

func (*CreateUserpool) Run added in v1.2.0 

func (cmd *CreateUserpool) Run(renv env.Running, params map[string]any) (any, error)

type CreateVolume 

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

func NewCreateVolume 

func NewCreateVolume(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateVolume

func (*CreateVolume) ExtractResult 

func (cmd *CreateVolume) ExtractResult(i any) string

func (*CreateVolume) ParamsSpec 

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

func (*CreateVolume) Run 

func (cmd *CreateVolume) Run(renv env.Running, params map[string]any) (any, error)

type CreateVpc 

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

func NewCreateVpc 

func NewCreateVpc(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateVpc

func (*CreateVpc) AfterRun 

func (cmd *CreateVpc) AfterRun(renv env.Running, output any) error

func (*CreateVpc) ExtractResult 

func (cmd *CreateVpc) ExtractResult(i any) string

func (*CreateVpc) ParamsSpec 

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

func (*CreateVpc) Run 

func (cmd *CreateVpc) Run(renv env.Running, params map[string]any) (any, error)

type CreateVpcendpoint added in v1.2.0 

type CreateVpcendpoint struct {
	Vpc     *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc"`
	Service *string `awsName:"ServiceName" awsType:"awsstr" templateName:"service"`
	// Gateway endpoints attach to route tables and cost nothing; Interface endpoints
	// place an ENI in each subnet and are billed hourly. The distinction decides which
	// of the two sets of params below applies, so the type is required rather than
	// defaulted to the cheaper one by accident.
	Type           *string   `awsName:"VpcEndpointType" awsType:"awsstr" templateName:"type"`
	Subnets        []*string `awsName:"SubnetIds" awsType:"awsstringslice" templateName:"subnets"`
	Securitygroups []*string `awsName:"SecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroups"`
	RouteTables    []*string `awsName:"RouteTableIds" awsType:"awsstringslice" templateName:"routetables"`
	PrivateDNS     *bool     `awsName:"PrivateDnsEnabled" awsType:"awsbool" templateName:"private-dns"`
	PolicyFile     *string   `awsName:"PolicyDocument" awsType:"awsfiletostring" templateName:"policy-file"`
	// contains filtered or unexported fields
}

func NewCreateVpcendpoint added in v1.2.0 

func NewCreateVpcendpoint(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateVpcendpoint

func (*CreateVpcendpoint) ExtractResult added in v1.2.0 

func (cmd *CreateVpcendpoint) ExtractResult(i any) string

func (*CreateVpcendpoint) ParamsSpec added in v1.2.0 

func (cmd *CreateVpcendpoint) ParamsSpec() params.Spec

func (*CreateVpcendpoint) Run added in v1.2.0 

func (cmd *CreateVpcendpoint) Run(renv env.Running, params map[string]any) (any, error)

type CreateVpcpeering added in v1.2.0 

type CreateVpcpeering struct {
	Vpc     *string `awsName:"VpcId" awsType:"awsstr" templateName:"vpc"`
	PeerVpc *string `awsName:"PeerVpcId" awsType:"awsstr" templateName:"peer-vpc"`
	// Needed when the other VPC is in a different account or region; the request goes to
	// that account for acceptance.
	PeerOwner  *string `awsName:"PeerOwnerId" awsType:"awsstr" templateName:"peer-owner"`
	PeerRegion *string `awsName:"PeerRegion" awsType:"awsstr" templateName:"peer-region"`
	// contains filtered or unexported fields
}

A peering connection is requested by one VPC and accepted by the other, so creating one leaves it pending-acceptance rather than active. `start vpcpeering` is the accept step, which is a separate call and often a separate account.

func NewCreateVpcpeering added in v1.2.0 

func NewCreateVpcpeering(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateVpcpeering

func (*CreateVpcpeering) ExtractResult added in v1.2.0 

func (cmd *CreateVpcpeering) ExtractResult(i any) string

func (*CreateVpcpeering) ParamsSpec added in v1.2.0 

func (cmd *CreateVpcpeering) ParamsSpec() params.Spec

func (*CreateVpcpeering) Run added in v1.2.0 

func (cmd *CreateVpcpeering) Run(renv env.Running, params map[string]any) (any, error)

type CreateWebacl added in v1.2.0 

type CreateWebacl struct {
	Name  *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Scope *string `awsName:"Scope" awsType:"awsstr" templateName:"scope"`
	// Required by AWS: an ACL with no default action would neither allow nor block.
	DefaultActionFile *string `awsName:"DefaultAction" awsType:"awsfiletostruct" templateName:"default-action-file"`
	VisibilityFile    *string `awsName:"VisibilityConfig" awsType:"awsfiletostruct" templateName:"visibility-file"`
	RulesFile         *string `awsName:"Rules" awsType:"awsfiletostruct" templateName:"rules-file"`
	Description       *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

A web ACL and a rule group are documents rather than sets of flags: the default action, the visibility config and the rules themselves are nested structures with no flat spelling. Those three come from a JSON file, in the same shape the AWS CLI accepts, while the name and scope stay ordinary params because they are what the user thinks in.

func NewCreateWebacl added in v1.2.0 

func NewCreateWebacl(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateWebacl

func (*CreateWebacl) BeforeRun added in v1.2.0 

func (cmd *CreateWebacl) BeforeRun(renv env.Running) error

func (*CreateWebacl) ExtractResult added in v1.2.0 

func (cmd *CreateWebacl) ExtractResult(i any) string

func (*CreateWebacl) ParamsSpec added in v1.2.0 

func (cmd *CreateWebacl) ParamsSpec() params.Spec

func (*CreateWebacl) Run added in v1.2.0 

func (cmd *CreateWebacl) Run(renv env.Running, params map[string]any) (any, error)

type CreateZone 

type CreateZone struct {
	Callerreference *string `awsName:"CallerReference" awsType:"awsstr" templateName:"callerreference"`
	Name            *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *CreateZone

func (*CreateZone) ExtractResult 

func (cmd *CreateZone) ExtractResult(i any) string

func (*CreateZone) ParamsSpec 

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

func (*CreateZone) Run 

func (cmd *CreateZone) Run(renv env.Running, params map[string]any) (any, error)

type Definition 

type Definition struct {
	Action, Entity, API string
	Params              params.Rule
}

func AWSLookupDefinitions 

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

type DeleteAccelerator added in v1.2.0 

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

An accelerator must be disabled before it can be deleted, which AWS enforces rather than doing for you — hence `update accelerator enabled=false` first.

func NewDeleteAccelerator added in v1.2.0 

func NewDeleteAccelerator(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteAccelerator

func (*DeleteAccelerator) ParamsSpec added in v1.2.0 

func (cmd *DeleteAccelerator) ParamsSpec() params.Spec

func (*DeleteAccelerator) Run added in v1.2.0 

func (cmd *DeleteAccelerator) Run(renv env.Running, params map[string]any) (any, error)

type DeleteAcceleratorlistener added in v1.2.0 

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

func NewDeleteAcceleratorlistener added in v1.2.0 

func NewDeleteAcceleratorlistener(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteAcceleratorlistener

func (*DeleteAcceleratorlistener) ParamsSpec added in v1.2.0 

func (cmd *DeleteAcceleratorlistener) ParamsSpec() params.Spec

func (*DeleteAcceleratorlistener) Run added in v1.2.0 

func (cmd *DeleteAcceleratorlistener) Run(renv env.Running, params map[string]any) (any, error)

type DeleteAccesskey 

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

func NewDeleteAccesskey 

func NewDeleteAccesskey(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteAccesskey

func (*DeleteAccesskey) ParamsSpec 

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

func (*DeleteAccesskey) Run 

func (cmd *DeleteAccesskey) Run(renv env.Running, params map[string]any) (any, error)

type DeleteAlarm 

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

func NewDeleteAlarm 

func NewDeleteAlarm(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteAlarm

func (*DeleteAlarm) ParamsSpec 

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

func (*DeleteAlarm) Run 

func (cmd *DeleteAlarm) Run(renv env.Running, params map[string]any) (any, error)

type DeleteApigateway 

type DeleteApigateway struct {
	ID *string `awsName:"ApiId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteApigateway 

func NewDeleteApigateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteApigateway

func (*DeleteApigateway) ParamsSpec 

func (cmd *DeleteApigateway) ParamsSpec() params.Spec

func (*DeleteApigateway) Run 

func (cmd *DeleteApigateway) Run(renv env.Running, params map[string]any) (any, error)

type DeleteApigatewayroute 

type DeleteApigatewayroute struct {
	API *string `awsName:"ApiId" awsType:"awsstr" templateName:"api"`
	ID  *string `awsName:"RouteId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteApigatewayroute 

func NewDeleteApigatewayroute(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteApigatewayroute

func (*DeleteApigatewayroute) ParamsSpec 

func (cmd *DeleteApigatewayroute) ParamsSpec() params.Spec

func (*DeleteApigatewayroute) Run 

func (cmd *DeleteApigatewayroute) Run(renv env.Running, params map[string]any) (any, error)

type DeleteApigatewaystage 

type DeleteApigatewaystage struct {
	API  *string `awsName:"ApiId" awsType:"awsstr" templateName:"api"`
	Name *string `awsName:"StageName" awsType:"awsstr" templateName:"name"`
	// contains filtered or unexported fields
}

func NewDeleteApigatewaystage 

func NewDeleteApigatewaystage(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteApigatewaystage

func (*DeleteApigatewaystage) ParamsSpec 

func (cmd *DeleteApigatewaystage) ParamsSpec() params.Spec

func (*DeleteApigatewaystage) Run 

func (cmd *DeleteApigatewaystage) Run(renv env.Running, params map[string]any) (any, error)

type DeleteApplication added in v1.2.0 

type DeleteApplication struct {
	Name *string `awsName:"ApplicationName" awsType:"awsstr" templateName:"name"`
	// An application with live environments cannot be deleted without this, and using
	// it terminates them — so it is opt-in rather than a default.
	Force *bool `awsName:"TerminateEnvByForce" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDeleteApplication added in v1.2.0 

func NewDeleteApplication(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteApplication

func (*DeleteApplication) ParamsSpec added in v1.2.0 

func (cmd *DeleteApplication) ParamsSpec() params.Spec

func (*DeleteApplication) Run added in v1.2.0 

func (cmd *DeleteApplication) Run(renv env.Running, params map[string]any) (any, error)

type DeleteAppscalingpolicy 

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

func NewDeleteAppscalingpolicy 

func NewDeleteAppscalingpolicy(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteAppscalingpolicy

func (*DeleteAppscalingpolicy) ParamsSpec 

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

func (*DeleteAppscalingpolicy) Run 

func (cmd *DeleteAppscalingpolicy) Run(renv env.Running, params map[string]any) (any, error)

type DeleteAppscalingtarget 

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

func NewDeleteAppscalingtarget 

func NewDeleteAppscalingtarget(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteAppscalingtarget

func (*DeleteAppscalingtarget) ParamsSpec 

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

func (*DeleteAppscalingtarget) Run 

func (cmd *DeleteAppscalingtarget) Run(renv env.Running, params map[string]any) (any, error)

type DeleteBackupplan added in v1.2.0 

type DeleteBackupplan struct {
	ID *string `awsName:"BackupPlanId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteBackupplan added in v1.2.0 

func NewDeleteBackupplan(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteBackupplan

func (*DeleteBackupplan) ParamsSpec added in v1.2.0 

func (cmd *DeleteBackupplan) ParamsSpec() params.Spec

func (*DeleteBackupplan) Run added in v1.2.0 

func (cmd *DeleteBackupplan) Run(renv env.Running, params map[string]any) (any, error)

type DeleteBackupvault added in v1.2.0 

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

A vault holding recovery points cannot be deleted, which AWS enforces — so this does not destroy backups by accident.

func NewDeleteBackupvault added in v1.2.0 

func NewDeleteBackupvault(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteBackupvault

func (*DeleteBackupvault) ParamsSpec added in v1.2.0 

func (cmd *DeleteBackupvault) ParamsSpec() params.Spec

func (*DeleteBackupvault) Run added in v1.2.0 

func (cmd *DeleteBackupvault) Run(renv env.Running, params map[string]any) (any, error)

type DeleteBroker added in v1.2.0 

type DeleteBroker struct {

	// The broker id, not the name: broker names are not unique across time and the API
	// takes the id.
	ID *string `awsName:"BrokerId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteBroker added in v1.2.0 

func NewDeleteBroker(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteBroker

func (*DeleteBroker) ParamsSpec added in v1.2.0 

func (cmd *DeleteBroker) ParamsSpec() params.Spec

func (*DeleteBroker) Run added in v1.2.0 

func (cmd *DeleteBroker) Run(renv env.Running, params map[string]any) (any, error)

type DeleteBucket 

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

func NewDeleteBucket 

func NewDeleteBucket(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteBucket

func (*DeleteBucket) ParamsSpec 

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

func (*DeleteBucket) Run 

func (cmd *DeleteBucket) Run(renv env.Running, params map[string]any) (any, error)

type DeleteBuildproject added in v1.2.0 

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

func NewDeleteBuildproject added in v1.2.0 

func NewDeleteBuildproject(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteBuildproject

func (*DeleteBuildproject) ParamsSpec added in v1.2.0 

func (cmd *DeleteBuildproject) ParamsSpec() params.Spec

func (*DeleteBuildproject) Run added in v1.2.0 

func (cmd *DeleteBuildproject) Run(renv env.Running, params map[string]any) (any, error)

type DeleteCachecluster added in v1.2.0 

type DeleteCachecluster struct {
	ID       *string `awsName:"CacheClusterId" awsType:"awsstr" templateName:"id"`
	Snapshot *string `awsName:"FinalSnapshotIdentifier" awsType:"awsstr" templateName:"snapshot"`
	// contains filtered or unexported fields
}

func NewDeleteCachecluster added in v1.2.0 

func NewDeleteCachecluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteCachecluster

func (*DeleteCachecluster) ParamsSpec added in v1.2.0 

func (cmd *DeleteCachecluster) ParamsSpec() params.Spec

func (*DeleteCachecluster) Run added in v1.2.0 

func (cmd *DeleteCachecluster) Run(renv env.Running, params map[string]any) (any, error)

type DeleteCachesubnetgroup added in v1.2.0 

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

func NewDeleteCachesubnetgroup added in v1.2.0 

func NewDeleteCachesubnetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteCachesubnetgroup

func (*DeleteCachesubnetgroup) ParamsSpec added in v1.2.0 

func (cmd *DeleteCachesubnetgroup) ParamsSpec() params.Spec

func (*DeleteCachesubnetgroup) Run added in v1.2.0 

func (cmd *DeleteCachesubnetgroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteCertificate 

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

func NewDeleteCertificate 

func NewDeleteCertificate(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteCertificate

func (*DeleteCertificate) ParamsSpec 

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

func (*DeleteCertificate) Run 

func (cmd *DeleteCertificate) Run(renv env.Running, params map[string]any) (any, error)

type DeleteClassicLoadbalancer 

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

func NewDeleteClassicLoadbalancer 

func NewDeleteClassicLoadbalancer(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteClassicLoadbalancer

func (*DeleteClassicLoadbalancer) ParamsSpec 

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

func (*DeleteClassicLoadbalancer) Run 

func (cmd *DeleteClassicLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type DeleteConfigrule added in v1.2.0 

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

func NewDeleteConfigrule added in v1.2.0 

func NewDeleteConfigrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteConfigrule

func (*DeleteConfigrule) ParamsSpec added in v1.2.0 

func (cmd *DeleteConfigrule) ParamsSpec() params.Spec

func (*DeleteConfigrule) Run added in v1.2.0 

func (cmd *DeleteConfigrule) Run(renv env.Running, params map[string]any) (any, error)

type DeleteConfigurationset added in v1.2.0 

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

func NewDeleteConfigurationset added in v1.2.0 

func NewDeleteConfigurationset(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteConfigurationset

func (*DeleteConfigurationset) ParamsSpec added in v1.2.0 

func (cmd *DeleteConfigurationset) ParamsSpec() params.Spec

func (*DeleteConfigurationset) Run added in v1.2.0 

func (cmd *DeleteConfigurationset) Run(renv env.Running, params map[string]any) (any, error)

type DeleteContainercluster 

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

func NewDeleteContainercluster 

func NewDeleteContainercluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteContainercluster

func (*DeleteContainercluster) ParamsSpec 

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

func (*DeleteContainercluster) Run 

func (cmd *DeleteContainercluster) Run(renv env.Running, params map[string]any) (any, error)

type DeleteContainertask 

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

func NewDeleteContainertask 

func NewDeleteContainertask(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteContainertask

func (*DeleteContainertask) ManualRun 

func (cmd *DeleteContainertask) ManualRun(renv env.Running) (any, error)

func (*DeleteContainertask) ParamsSpec 

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

func (*DeleteContainertask) Run 

func (cmd *DeleteContainertask) Run(renv env.Running, params map[string]any) (any, error)

type DeleteCrawler added in v1.2.0 

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

func NewDeleteCrawler added in v1.2.0 

func NewDeleteCrawler(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteCrawler

func (*DeleteCrawler) ParamsSpec added in v1.2.0 

func (cmd *DeleteCrawler) ParamsSpec() params.Spec

func (*DeleteCrawler) Run added in v1.2.0 

func (cmd *DeleteCrawler) Run(renv env.Running, params map[string]any) (any, error)

type DeleteDatabase 

type DeleteDatabase struct {
	ID           *string `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"id"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteDatabase

func (*DeleteDatabase) ParamsSpec 

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

func (*DeleteDatabase) Run 

func (cmd *DeleteDatabase) Run(renv env.Running, params map[string]any) (any, error)

type DeleteDbsubnetgroup 

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

func NewDeleteDbsubnetgroup 

func NewDeleteDbsubnetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteDbsubnetgroup

func (*DeleteDbsubnetgroup) ParamsSpec 

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

func (*DeleteDbsubnetgroup) Run 

func (cmd *DeleteDbsubnetgroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteDeployapplication added in v1.2.0 

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

func NewDeleteDeployapplication added in v1.2.0 

func NewDeleteDeployapplication(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteDeployapplication

func (*DeleteDeployapplication) ParamsSpec added in v1.2.0 

func (cmd *DeleteDeployapplication) ParamsSpec() params.Spec

func (*DeleteDeployapplication) Run added in v1.2.0 

func (cmd *DeleteDeployapplication) Run(renv env.Running, params map[string]any) (any, error)

type DeleteDeploymentgroup added in v1.2.0 

type DeleteDeploymentgroup struct {
	Name        *string `awsName:"DeploymentGroupName" awsType:"awsstr" templateName:"name"`
	Application *string `awsName:"ApplicationName" awsType:"awsstr" templateName:"application"`
	// contains filtered or unexported fields
}

func NewDeleteDeploymentgroup added in v1.2.0 

func NewDeleteDeploymentgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteDeploymentgroup

func (*DeleteDeploymentgroup) ParamsSpec added in v1.2.0 

func (cmd *DeleteDeploymentgroup) ParamsSpec() params.Spec

A deployment group name is only unique within its application, so both are required.

func (*DeleteDeploymentgroup) Run added in v1.2.0 

func (cmd *DeleteDeploymentgroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteDiscoveryservice added in v1.2.0 

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

func NewDeleteDiscoveryservice added in v1.2.0 

func NewDeleteDiscoveryservice(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteDiscoveryservice

func (*DeleteDiscoveryservice) ParamsSpec added in v1.2.0 

func (cmd *DeleteDiscoveryservice) ParamsSpec() params.Spec

func (*DeleteDiscoveryservice) Run added in v1.2.0 

func (cmd *DeleteDiscoveryservice) Run(renv env.Running, params map[string]any) (any, error)

type DeleteDistribution 

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

func NewDeleteDistribution 

func NewDeleteDistribution(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteDistribution

func (*DeleteDistribution) ManualRun 

func (cmd *DeleteDistribution) ManualRun(renv env.Running) (any, error)

func (*DeleteDistribution) ParamsSpec 

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

func (*DeleteDistribution) Run 

func (cmd *DeleteDistribution) Run(renv env.Running, params map[string]any) (any, error)

type DeleteDynamodbtable 

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

func NewDeleteDynamodbtable 

func NewDeleteDynamodbtable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteDynamodbtable

func (*DeleteDynamodbtable) ParamsSpec 

func (cmd *DeleteDynamodbtable) ParamsSpec() params.Spec

func (*DeleteDynamodbtable) Run 

func (cmd *DeleteDynamodbtable) Run(renv env.Running, params map[string]any) (any, error)

type DeleteEkscluster 

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

func NewDeleteEkscluster 

func NewDeleteEkscluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteEkscluster

func (*DeleteEkscluster) ParamsSpec 

func (cmd *DeleteEkscluster) ParamsSpec() params.Spec

func (*DeleteEkscluster) Run 

func (cmd *DeleteEkscluster) Run(renv env.Running, params map[string]any) (any, error)

type DeleteEksnodegroup 

type DeleteEksnodegroup struct {
	Name    *string `awsName:"NodegroupName" awsType:"awsstr" templateName:"name"`
	Cluster *string `awsName:"ClusterName" awsType:"awsstr" templateName:"cluster"`
	// contains filtered or unexported fields
}

func NewDeleteEksnodegroup 

func NewDeleteEksnodegroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteEksnodegroup

func (*DeleteEksnodegroup) ParamsSpec 

func (cmd *DeleteEksnodegroup) ParamsSpec() params.Spec

func (*DeleteEksnodegroup) Run 

func (cmd *DeleteEksnodegroup) Run(renv env.Running, params map[string]any) (any, 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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteElasticip

func (*DeleteElasticip) ParamsSpec 

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

func (*DeleteElasticip) Run 

func (cmd *DeleteElasticip) Run(renv env.Running, params map[string]any) (any, error)

type DeleteEmailidentity added in v1.2.0 

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

func NewDeleteEmailidentity added in v1.2.0 

func NewDeleteEmailidentity(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteEmailidentity

func (*DeleteEmailidentity) ParamsSpec added in v1.2.0 

func (cmd *DeleteEmailidentity) ParamsSpec() params.Spec

func (*DeleteEmailidentity) Run added in v1.2.0 

func (cmd *DeleteEmailidentity) Run(renv env.Running, params map[string]any) (any, error)

type DeleteEnvironment added in v1.2.0 

type DeleteEnvironment struct {
	Name *string `awsName:"EnvironmentName" awsType:"awsstr" templateName:"name"`
	// Keeping the resources behind means the load balancer and instances survive the
	// environment, which is rarely what is wanted but is occasionally deliberate.
	KeepResources *bool `awsName:"TerminateResources" awsType:"awsbool" templateName:"terminate-resources"`
	Force         *bool `awsName:"ForceTerminate" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

Terminating is Beanstalk's word for deleting an environment, and it is what the delete verb maps to here.

func NewDeleteEnvironment added in v1.2.0 

func NewDeleteEnvironment(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteEnvironment

func (*DeleteEnvironment) ParamsSpec added in v1.2.0 

func (cmd *DeleteEnvironment) ParamsSpec() params.Spec

func (*DeleteEnvironment) Run added in v1.2.0 

func (cmd *DeleteEnvironment) Run(renv env.Running, params map[string]any) (any, error)

type DeleteEventbus added in v1.2.0 

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

func NewDeleteEventbus added in v1.2.0 

func NewDeleteEventbus(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteEventbus

func (*DeleteEventbus) ParamsSpec added in v1.2.0 

func (cmd *DeleteEventbus) ParamsSpec() params.Spec

func (*DeleteEventbus) Run added in v1.2.0 

func (cmd *DeleteEventbus) Run(renv env.Running, params map[string]any) (any, error)

type DeleteEventrule added in v1.2.0 

type DeleteEventrule struct {
	Name     *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	EventBus *string `awsName:"EventBusName" awsType:"awsstr" templateName:"eventbus"`
	// A rule with targets still attached cannot be deleted without this.
	Force *bool `awsName:"Force" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDeleteEventrule added in v1.2.0 

func NewDeleteEventrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteEventrule

func (*DeleteEventrule) ParamsSpec added in v1.2.0 

func (cmd *DeleteEventrule) ParamsSpec() params.Spec

func (*DeleteEventrule) Run added in v1.2.0 

func (cmd *DeleteEventrule) Run(renv env.Running, params map[string]any) (any, error)

type DeleteFilesystem 

type DeleteFilesystem struct {
	ID *string `awsName:"FileSystemId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteFilesystem 

func NewDeleteFilesystem(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteFilesystem

func (*DeleteFilesystem) ParamsSpec 

func (cmd *DeleteFilesystem) ParamsSpec() params.Spec

func (*DeleteFilesystem) Run 

func (cmd *DeleteFilesystem) Run(renv env.Running, params map[string]any) (any, error)

type DeleteFsxbackup added in v1.2.0 

type DeleteFsxbackup struct {
	ID *string `awsName:"BackupId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteFsxbackup added in v1.2.0 

func NewDeleteFsxbackup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteFsxbackup

func (*DeleteFsxbackup) ParamsSpec added in v1.2.0 

func (cmd *DeleteFsxbackup) ParamsSpec() params.Spec

func (*DeleteFsxbackup) Run added in v1.2.0 

func (cmd *DeleteFsxbackup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteFsxfilesystem added in v1.2.0 

type DeleteFsxfilesystem struct {
	ID *string `awsName:"FileSystemId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteFsxfilesystem added in v1.2.0 

func NewDeleteFsxfilesystem(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteFsxfilesystem

func (*DeleteFsxfilesystem) ParamsSpec added in v1.2.0 

func (cmd *DeleteFsxfilesystem) ParamsSpec() params.Spec

func (*DeleteFsxfilesystem) Run added in v1.2.0 

func (cmd *DeleteFsxfilesystem) Run(renv env.Running, params map[string]any) (any, error)

type DeleteFunction 

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

func NewDeleteFunction 

func NewDeleteFunction(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteFunction

func (*DeleteFunction) ParamsSpec 

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

func (*DeleteFunction) Run 

func (cmd *DeleteFunction) Run(renv env.Running, params map[string]any) (any, error)

type DeleteGluedatabase added in v1.2.0 

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

func NewDeleteGluedatabase added in v1.2.0 

func NewDeleteGluedatabase(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteGluedatabase

func (*DeleteGluedatabase) ParamsSpec added in v1.2.0 

func (cmd *DeleteGluedatabase) ParamsSpec() params.Spec

Deleting a database deletes every table in it, which is worth knowing but is AWS's behavior rather than something awless can soften.

func (*DeleteGluedatabase) Run added in v1.2.0 

func (cmd *DeleteGluedatabase) Run(renv env.Running, params map[string]any) (any, error)

type DeleteGroup 

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

func NewDeleteGroup 

func NewDeleteGroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteGroup

func (*DeleteGroup) ParamsSpec 

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

func (*DeleteGroup) Run 

func (cmd *DeleteGroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteIdentitypool added in v1.2.0 

type DeleteIdentitypool struct {
	ID *string `awsName:"IdentityPoolId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteIdentitypool added in v1.2.0 

func NewDeleteIdentitypool(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteIdentitypool

func (*DeleteIdentitypool) ParamsSpec added in v1.2.0 

func (cmd *DeleteIdentitypool) ParamsSpec() params.Spec

func (*DeleteIdentitypool) Run added in v1.2.0 

func (cmd *DeleteIdentitypool) Run(renv env.Running, params map[string]any) (any, error)

type DeleteImage 

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

func NewDeleteImage 

func NewDeleteImage(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteImage

func (*DeleteImage) ManualRun 

func (cmd *DeleteImage) ManualRun(renv env.Running) (any, error)

func (*DeleteImage) ParamsSpec 

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

func (*DeleteImage) Run 

func (cmd *DeleteImage) Run(renv env.Running, params map[string]any) (any, error)

type DeleteInstance 

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

func NewDeleteInstance 

func NewDeleteInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteInstance

func (*DeleteInstance) ParamsSpec 

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

func (*DeleteInstance) Run 

func (cmd *DeleteInstance) Run(renv env.Running, params map[string]any) (any, error)

type DeleteInstanceprofile 

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

func NewDeleteInstanceprofile 

func NewDeleteInstanceprofile(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteInstanceprofile

func (*DeleteInstanceprofile) ParamsSpec 

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

func (*DeleteInstanceprofile) Run 

func (cmd *DeleteInstanceprofile) Run(renv env.Running, params map[string]any) (any, error)

type DeleteInternetgateway 

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

func NewDeleteInternetgateway 

func NewDeleteInternetgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteInternetgateway

func (*DeleteInternetgateway) ParamsSpec 

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

func (*DeleteInternetgateway) Run 

func (cmd *DeleteInternetgateway) Run(renv env.Running, params map[string]any) (any, error)

type DeleteIpset added in v1.2.0 

type DeleteIpset struct {
	Name  *string `templateName:"name"`
	Scope *string `templateName:"scope"`
	// contains filtered or unexported fields
}

func NewDeleteIpset added in v1.2.0 

func NewDeleteIpset(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteIpset

func (*DeleteIpset) ManualRun added in v1.2.0 

func (cmd *DeleteIpset) ManualRun(renv env.Running) (any, error)

func (*DeleteIpset) ParamsSpec added in v1.2.0 

func (cmd *DeleteIpset) ParamsSpec() params.Spec

func (*DeleteIpset) Run added in v1.2.0 

func (cmd *DeleteIpset) Run(renv env.Running, params map[string]any) (any, error)

type DeleteJob added in v1.2.0 

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

func NewDeleteJob added in v1.2.0 

func NewDeleteJob(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteJob

func (*DeleteJob) ParamsSpec added in v1.2.0 

func (cmd *DeleteJob) ParamsSpec() params.Spec

func (*DeleteJob) Run added in v1.2.0 

func (cmd *DeleteJob) Run(renv env.Running, params map[string]any) (any, error)

type DeleteKafkacluster added in v1.2.0 

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

DeleteCluster takes the ARN rather than the name, and the ARN is what the graph records.

func NewDeleteKafkacluster added in v1.2.0 

func NewDeleteKafkacluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteKafkacluster

func (*DeleteKafkacluster) ParamsSpec added in v1.2.0 

func (cmd *DeleteKafkacluster) ParamsSpec() params.Spec

func (*DeleteKafkacluster) Run added in v1.2.0 

func (cmd *DeleteKafkacluster) Run(renv env.Running, params map[string]any) (any, error)

type DeleteKeypair 

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

func NewDeleteKeypair 

func NewDeleteKeypair(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteKeypair

func (*DeleteKeypair) ParamsSpec 

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

func (*DeleteKeypair) Run 

func (cmd *DeleteKeypair) Run(renv env.Running, params map[string]any) (any, error)

type DeleteLaunchconfiguration 

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

func NewDeleteLaunchconfiguration 

func NewDeleteLaunchconfiguration(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteLaunchconfiguration

func (*DeleteLaunchconfiguration) ParamsSpec 

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

func (*DeleteLaunchconfiguration) Run 

func (cmd *DeleteLaunchconfiguration) Run(renv env.Running, params map[string]any) (any, error)

type DeleteListener 

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

func NewDeleteListener 

func NewDeleteListener(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteListener

func (*DeleteListener) ParamsSpec 

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

func (*DeleteListener) Run 

func (cmd *DeleteListener) Run(renv env.Running, params map[string]any) (any, error)

type DeleteLoadbalancer 

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

func NewDeleteLoadbalancer 

func NewDeleteLoadbalancer(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteLoadbalancer

func (*DeleteLoadbalancer) ParamsSpec 

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

func (*DeleteLoadbalancer) Run 

func (cmd *DeleteLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type DeleteLoggroup 

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

func NewDeleteLoggroup 

func NewDeleteLoggroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteLoggroup

func (*DeleteLoggroup) ParamsSpec 

func (cmd *DeleteLoggroup) ParamsSpec() params.Spec

func (*DeleteLoggroup) Run 

func (cmd *DeleteLoggroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteLoginprofile 

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

func NewDeleteLoginprofile 

func NewDeleteLoginprofile(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteLoginprofile

func (*DeleteLoginprofile) ParamsSpec 

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

func (*DeleteLoginprofile) Run 

func (cmd *DeleteLoginprofile) Run(renv env.Running, params map[string]any) (any, error)

type DeleteMfadevice 

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

func NewDeleteMfadevice 

func NewDeleteMfadevice(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteMfadevice

func (*DeleteMfadevice) ParamsSpec 

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

func (*DeleteMfadevice) Run 

func (cmd *DeleteMfadevice) Run(renv env.Running, params map[string]any) (any, error)

type DeleteNamespace added in v1.2.0 

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

func NewDeleteNamespace added in v1.2.0 

func NewDeleteNamespace(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteNamespace

func (*DeleteNamespace) ParamsSpec added in v1.2.0 

func (cmd *DeleteNamespace) ParamsSpec() params.Spec

A namespace with services still in it cannot be deleted, which AWS enforces.

func (*DeleteNamespace) Run added in v1.2.0 

func (cmd *DeleteNamespace) Run(renv env.Running, params map[string]any) (any, error)

type DeleteNatgateway 

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

func NewDeleteNatgateway 

func NewDeleteNatgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteNatgateway

func (*DeleteNatgateway) ParamsSpec 

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

func (*DeleteNatgateway) Run 

func (cmd *DeleteNatgateway) Run(renv env.Running, params map[string]any) (any, error)

type DeleteNetworkinterface 

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

func NewDeleteNetworkinterface 

func NewDeleteNetworkinterface(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteNetworkinterface

func (*DeleteNetworkinterface) ParamsSpec 

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

func (*DeleteNetworkinterface) Run 

func (cmd *DeleteNetworkinterface) Run(renv env.Running, params map[string]any) (any, error)

type DeletePipeline added in v1.2.0 

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

func NewDeletePipeline added in v1.2.0 

func NewDeletePipeline(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeletePipeline

func (*DeletePipeline) ParamsSpec added in v1.2.0 

func (cmd *DeletePipeline) ParamsSpec() params.Spec

func (*DeletePipeline) Run added in v1.2.0 

func (cmd *DeletePipeline) Run(renv env.Running, params map[string]any) (any, error)

type DeletePolicy 

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

func NewDeletePolicy 

func NewDeletePolicy(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeletePolicy

func (*DeletePolicy) BeforeRun 

func (cmd *DeletePolicy) BeforeRun(renv env.Running) error

func (*DeletePolicy) ParamsSpec 

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

func (*DeletePolicy) Run 

func (cmd *DeletePolicy) Run(renv env.Running, params map[string]any) (any, error)

type DeleteQueue 

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

func NewDeleteQueue 

func NewDeleteQueue(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteQueue

func (*DeleteQueue) ParamsSpec 

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

func (*DeleteQueue) Run 

func (cmd *DeleteQueue) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRecord 

type DeleteRecord struct {
	Zone   *string   `templateName:"zone"`
	Name   *string   `templateName:"name"`
	Type   *string   `templateName:"type"`
	Values []*string `templateName:"values"`
	TTL    *int64    `templateName:"ttl"`
	// contains filtered or unexported fields
}

func NewDeleteRecord 

func NewDeleteRecord(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRecord

func (*DeleteRecord) ExtractResult 

func (cmd *DeleteRecord) ExtractResult(i any) string

func (*DeleteRecord) ManualRun 

func (cmd *DeleteRecord) ManualRun(renv env.Running) (any, error)

func (*DeleteRecord) ParamsSpec 

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

func (*DeleteRecord) Run 

func (cmd *DeleteRecord) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRedshiftcluster added in v1.2.0 

type DeleteRedshiftcluster struct {
	ID *string `awsName:"ClusterIdentifier" awsType:"awsstr" templateName:"id"`
	// Redshift refuses to delete without either a final snapshot name or an explicit
	// instruction to skip one, so one of the two is required rather than defaulted —
	// silently skipping a snapshot on a data warehouse is not a safe default.
	Snapshot     *string `awsName:"FinalClusterSnapshotIdentifier" awsType:"awsstr" templateName:"snapshot"`
	SkipSnapshot *bool   `awsName:"SkipFinalClusterSnapshot" awsType:"awsbool" templateName:"skip-snapshot"`
	// contains filtered or unexported fields
}

func NewDeleteRedshiftcluster added in v1.2.0 

func NewDeleteRedshiftcluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRedshiftcluster

func (*DeleteRedshiftcluster) ParamsSpec added in v1.2.0 

func (cmd *DeleteRedshiftcluster) ParamsSpec() params.Spec

func (*DeleteRedshiftcluster) Run added in v1.2.0 

func (cmd *DeleteRedshiftcluster) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRedshiftsubnetgroup added in v1.2.0 

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

func NewDeleteRedshiftsubnetgroup added in v1.2.0 

func NewDeleteRedshiftsubnetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRedshiftsubnetgroup

func (*DeleteRedshiftsubnetgroup) ParamsSpec added in v1.2.0 

func (cmd *DeleteRedshiftsubnetgroup) ParamsSpec() params.Spec

func (*DeleteRedshiftsubnetgroup) Run added in v1.2.0 

func (cmd *DeleteRedshiftsubnetgroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteReplicationgroup added in v1.2.0 

type DeleteReplicationgroup struct {
	ID       *string `awsName:"ReplicationGroupId" awsType:"awsstr" templateName:"id"`
	Snapshot *string `awsName:"FinalSnapshotIdentifier" awsType:"awsstr" templateName:"snapshot"`
	// RetainPrimaryCluster keeps the primary node running and removes only the
	// replicas, which is the difference between shrinking a group and destroying it.
	RetainPrimary *bool `awsName:"RetainPrimaryCluster" awsType:"awsbool" templateName:"retain-primary"`
	// contains filtered or unexported fields
}

func NewDeleteReplicationgroup added in v1.2.0 

func NewDeleteReplicationgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteReplicationgroup

func (*DeleteReplicationgroup) ParamsSpec added in v1.2.0 

func (cmd *DeleteReplicationgroup) ParamsSpec() params.Spec

func (*DeleteReplicationgroup) Run added in v1.2.0 

func (cmd *DeleteReplicationgroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRepository 

type DeleteRepository struct {
	Name    *string `awsName:"RepositoryName" awsType:"awsstr" templateName:"name"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRepository

func (*DeleteRepository) ParamsSpec 

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

func (*DeleteRepository) Run 

func (cmd *DeleteRepository) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRole 

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

func NewDeleteRole 

func NewDeleteRole(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRole

func (*DeleteRole) ManualRun 

func (cmd *DeleteRole) ManualRun(renv env.Running) (any, error)

func (*DeleteRole) ParamsSpec 

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

func (*DeleteRole) Run 

func (cmd *DeleteRole) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRoute 

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

func NewDeleteRoute 

func NewDeleteRoute(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRoute

func (*DeleteRoute) ParamsSpec 

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

func (*DeleteRoute) Run 

func (cmd *DeleteRoute) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRoutetable 

type DeleteRoutetable struct {
	ID *string `awsName:"RouteTableId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteRoutetable 

func NewDeleteRoutetable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRoutetable

func (*DeleteRoutetable) ParamsSpec 

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

func (*DeleteRoutetable) Run 

func (cmd *DeleteRoutetable) Run(renv env.Running, params map[string]any) (any, error)

type DeleteRulegroup added in v1.2.0 

type DeleteRulegroup struct {
	Name  *string `templateName:"name"`
	Scope *string `templateName:"scope"`
	// contains filtered or unexported fields
}

func NewDeleteRulegroup added in v1.2.0 

func NewDeleteRulegroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteRulegroup

func (*DeleteRulegroup) ManualRun added in v1.2.0 

func (cmd *DeleteRulegroup) ManualRun(renv env.Running) (any, error)

func (*DeleteRulegroup) ParamsSpec added in v1.2.0 

func (cmd *DeleteRulegroup) ParamsSpec() params.Spec

func (*DeleteRulegroup) Run added in v1.2.0 

func (cmd *DeleteRulegroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteS3object 

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

func NewDeleteS3object 

func NewDeleteS3object(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteS3object

func (*DeleteS3object) ParamsSpec 

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

func (*DeleteS3object) Run 

func (cmd *DeleteS3object) Run(renv env.Running, params map[string]any) (any, error)

type DeleteScalinggroup 

type DeleteScalinggroup struct {
	Name  *string `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name"`
	Force *bool   `awsName:"ForceDelete" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDeleteScalinggroup 

func NewDeleteScalinggroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteScalinggroup

func (*DeleteScalinggroup) ParamsSpec 

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

func (*DeleteScalinggroup) Run 

func (cmd *DeleteScalinggroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteScalingpolicy 

type DeleteScalingpolicy struct {
	ID *string `awsName:"PolicyName" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteScalingpolicy 

func NewDeleteScalingpolicy(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteScalingpolicy

func (*DeleteScalingpolicy) ParamsSpec 

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

func (*DeleteScalingpolicy) Run 

func (cmd *DeleteScalingpolicy) Run(renv env.Running, params map[string]any) (any, error)

type DeleteSecret 

type DeleteSecret struct {
	ID             *string `awsName:"SecretId" awsType:"awsstr" templateName:"id"`
	RecoveryWindow *int64  `awsName:"RecoveryWindowInDays" awsType:"awsint64" templateName:"recovery-window"`
	Force          *bool   `awsName:"ForceDeleteWithoutRecovery" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

DeleteSecret schedules deletion rather than deleting immediately, because that is the only behavior the API offers without force-delete. recovery-window defaults to the API's 30 days; force=true removes the secret with no recovery window and cannot be undone.

func NewDeleteSecret 

func NewDeleteSecret(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteSecret

func (*DeleteSecret) ParamsSpec 

func (cmd *DeleteSecret) ParamsSpec() params.Spec

func (*DeleteSecret) Run 

func (cmd *DeleteSecret) Run(renv env.Running, params map[string]any) (any, error)

type DeleteSecuritygroup 

type DeleteSecuritygroup struct {
	ID *string `awsName:"GroupId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteSecuritygroup 

func NewDeleteSecuritygroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteSecuritygroup

func (*DeleteSecuritygroup) ParamsSpec 

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

func (*DeleteSecuritygroup) Run 

func (cmd *DeleteSecuritygroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteSnapshot 

type DeleteSnapshot struct {
	ID *string `awsName:"SnapshotId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteSnapshot 

func NewDeleteSnapshot(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteSnapshot

func (*DeleteSnapshot) ParamsSpec 

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

func (*DeleteSnapshot) Run 

func (cmd *DeleteSnapshot) Run(renv env.Running, params map[string]any) (any, error)

type DeleteSsmparameter 

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

func NewDeleteSsmparameter 

func NewDeleteSsmparameter(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteSsmparameter

func (*DeleteSsmparameter) ParamsSpec 

func (cmd *DeleteSsmparameter) ParamsSpec() params.Spec

func (*DeleteSsmparameter) Run 

func (cmd *DeleteSsmparameter) Run(renv env.Running, params map[string]any) (any, error)

type DeleteStack 

type DeleteStack struct {
	Name            *string   `awsName:"StackName" awsType:"awsstr" templateName:"name"`
	RetainResources []*string `awsName:"RetainResources" awsType:"awsstringslice" templateName:"retain-resources"`
	// contains filtered or unexported fields
}

func NewDeleteStack 

func NewDeleteStack(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteStack

func (*DeleteStack) ParamsSpec 

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

func (*DeleteStack) Run 

func (cmd *DeleteStack) Run(renv env.Running, params map[string]any) (any, error)

type DeleteStatemachine added in v1.2.0 

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

func NewDeleteStatemachine added in v1.2.0 

func NewDeleteStatemachine(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteStatemachine

func (*DeleteStatemachine) ParamsSpec added in v1.2.0 

func (cmd *DeleteStatemachine) ParamsSpec() params.Spec

func (*DeleteStatemachine) Run added in v1.2.0 

func (cmd *DeleteStatemachine) Run(renv env.Running, params map[string]any) (any, error)

type DeleteStream added in v1.2.0 

type DeleteStream struct {
	Name *string `awsName:"StreamName" awsType:"awsstr" templateName:"name"`
	// Without this, deleting a stream that still has registered consumers fails.
	Force *bool `awsName:"EnforceConsumerDeletion" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDeleteStream added in v1.2.0 

func NewDeleteStream(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteStream

func (*DeleteStream) ParamsSpec added in v1.2.0 

func (cmd *DeleteStream) ParamsSpec() params.Spec

func (*DeleteStream) Run added in v1.2.0 

func (cmd *DeleteStream) Run(renv env.Running, params map[string]any) (any, error)

type DeleteSubnet 

type DeleteSubnet struct {
	ID *string `awsName:"SubnetId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteSubnet 

func NewDeleteSubnet(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteSubnet

func (*DeleteSubnet) ParamsSpec 

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

func (*DeleteSubnet) Run 

func (cmd *DeleteSubnet) Run(renv env.Running, params map[string]any) (any, error)

type DeleteSubscription 

type DeleteSubscription struct {
	ID *string `awsName:"SubscriptionArn" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteSubscription 

func NewDeleteSubscription(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteSubscription

func (*DeleteSubscription) ParamsSpec 

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

func (*DeleteSubscription) Run 

func (cmd *DeleteSubscription) Run(renv env.Running, params map[string]any) (any, error)

type DeleteTag 

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

func NewDeleteTag 

func NewDeleteTag(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteTag

func (*DeleteTag) ManualRun 

func (cmd *DeleteTag) ManualRun(renv env.Running) (any, error)

func (*DeleteTag) ParamsSpec 

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

func (*DeleteTag) Run 

func (cmd *DeleteTag) Run(renv env.Running, params map[string]any) (any, error)

type DeleteTargetgroup 

type DeleteTargetgroup struct {
	ID *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteTargetgroup 

func NewDeleteTargetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteTargetgroup

func (*DeleteTargetgroup) ParamsSpec 

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

func (*DeleteTargetgroup) Run 

func (cmd *DeleteTargetgroup) Run(renv env.Running, params map[string]any) (any, error)

type DeleteTopic 

type DeleteTopic struct {
	ID *string `awsName:"TopicArn" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteTopic 

func NewDeleteTopic(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteTopic

func (*DeleteTopic) ParamsSpec 

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

func (*DeleteTopic) Run 

func (cmd *DeleteTopic) Run(renv env.Running, params map[string]any) (any, error)

type DeleteTrail 

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

func NewDeleteTrail 

func NewDeleteTrail(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteTrail

func (*DeleteTrail) ParamsSpec 

func (cmd *DeleteTrail) ParamsSpec() params.Spec

func (*DeleteTrail) Run 

func (cmd *DeleteTrail) Run(renv env.Running, params map[string]any) (any, error)

type DeleteTransitgateway added in v1.2.0 

type DeleteTransitgateway struct {
	ID *string `awsName:"TransitGatewayId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteTransitgateway added in v1.2.0 

func NewDeleteTransitgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteTransitgateway

func (*DeleteTransitgateway) ParamsSpec added in v1.2.0 

func (cmd *DeleteTransitgateway) ParamsSpec() params.Spec

func (*DeleteTransitgateway) Run added in v1.2.0 

func (cmd *DeleteTransitgateway) Run(renv env.Running, params map[string]any) (any, error)

type DeleteTransitgatewayattachment added in v1.2.0 

type DeleteTransitgatewayattachment struct {
	ID *string `awsName:"TransitGatewayAttachmentId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteTransitgatewayattachment added in v1.2.0 

func NewDeleteTransitgatewayattachment(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteTransitgatewayattachment

func (*DeleteTransitgatewayattachment) ParamsSpec added in v1.2.0 

func (cmd *DeleteTransitgatewayattachment) ParamsSpec() params.Spec

func (*DeleteTransitgatewayattachment) Run added in v1.2.0 

func (cmd *DeleteTransitgatewayattachment) Run(renv env.Running, params map[string]any) (any, error)

type DeleteTransitgatewayroutetable added in v1.2.0 

type DeleteTransitgatewayroutetable struct {
	ID *string `awsName:"TransitGatewayRouteTableId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteTransitgatewayroutetable added in v1.2.0 

func NewDeleteTransitgatewayroutetable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteTransitgatewayroutetable

func (*DeleteTransitgatewayroutetable) ParamsSpec added in v1.2.0 

func (cmd *DeleteTransitgatewayroutetable) ParamsSpec() params.Spec

func (*DeleteTransitgatewayroutetable) Run added in v1.2.0 

func (cmd *DeleteTransitgatewayroutetable) Run(renv env.Running, params map[string]any) (any, error)

type DeleteUser 

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

func NewDeleteUser 

func NewDeleteUser(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteUser

func (*DeleteUser) ParamsSpec 

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

func (*DeleteUser) Run 

func (cmd *DeleteUser) Run(renv env.Running, params map[string]any) (any, error)

type DeleteUserpool added in v1.2.0 

type DeleteUserpool struct {

	// The id, not the name: user pool names are not unique and the API takes the id.
	ID *string `awsName:"UserPoolId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteUserpool added in v1.2.0 

func NewDeleteUserpool(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteUserpool

func (*DeleteUserpool) ParamsSpec added in v1.2.0 

func (cmd *DeleteUserpool) ParamsSpec() params.Spec

func (*DeleteUserpool) Run added in v1.2.0 

func (cmd *DeleteUserpool) Run(renv env.Running, params map[string]any) (any, error)

type DeleteVolume 

type DeleteVolume struct {
	ID *string `awsName:"VolumeId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteVolume 

func NewDeleteVolume(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteVolume

func (*DeleteVolume) ParamsSpec 

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

func (*DeleteVolume) Run 

func (cmd *DeleteVolume) Run(renv env.Running, params map[string]any) (any, error)

type DeleteVpc 

type DeleteVpc struct {
	ID *string `awsName:"VpcId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteVpc 

func NewDeleteVpc(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteVpc

func (*DeleteVpc) ParamsSpec 

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

func (*DeleteVpc) Run 

func (cmd *DeleteVpc) Run(renv env.Running, params map[string]any) (any, error)

type DeleteVpcendpoint added in v1.2.0 

type DeleteVpcendpoint struct {

	// The API deletes in bulk, hence the plural field, but one id at a time is what a
	// revert produces and what a user means.
	ID []*string `awsName:"VpcEndpointIds" awsType:"awsstringslice" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteVpcendpoint added in v1.2.0 

func NewDeleteVpcendpoint(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteVpcendpoint

func (*DeleteVpcendpoint) ParamsSpec added in v1.2.0 

func (cmd *DeleteVpcendpoint) ParamsSpec() params.Spec

func (*DeleteVpcendpoint) Run added in v1.2.0 

func (cmd *DeleteVpcendpoint) Run(renv env.Running, params map[string]any) (any, error)

type DeleteVpcpeering added in v1.2.0 

type DeleteVpcpeering struct {
	ID *string `awsName:"VpcPeeringConnectionId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDeleteVpcpeering added in v1.2.0 

func NewDeleteVpcpeering(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteVpcpeering

func (*DeleteVpcpeering) ParamsSpec added in v1.2.0 

func (cmd *DeleteVpcpeering) ParamsSpec() params.Spec

func (*DeleteVpcpeering) Run added in v1.2.0 

func (cmd *DeleteVpcpeering) Run(renv env.Running, params map[string]any) (any, error)

type DeleteWebacl added in v1.2.0 

type DeleteWebacl struct {
	Name  *string `templateName:"name"`
	Scope *string `templateName:"scope"`
	// contains filtered or unexported fields
}

func NewDeleteWebacl added in v1.2.0 

func NewDeleteWebacl(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteWebacl

func (*DeleteWebacl) ManualRun added in v1.2.0 

func (cmd *DeleteWebacl) ManualRun(renv env.Running) (any, error)

func (*DeleteWebacl) ParamsSpec added in v1.2.0 

func (cmd *DeleteWebacl) ParamsSpec() params.Spec

func (*DeleteWebacl) Run added in v1.2.0 

func (cmd *DeleteWebacl) Run(renv env.Running, params map[string]any) (any, error)

type DeleteZone 

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

func NewDeleteZone 

func NewDeleteZone(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DeleteZone

func (*DeleteZone) ParamsSpec 

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

func (*DeleteZone) Run 

func (cmd *DeleteZone) Run(renv env.Running, params map[string]any) (any, error)

type DetachAlarm 

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

func NewDetachAlarm 

func NewDetachAlarm(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachAlarm

func (*DetachAlarm) ManualRun 

func (cmd *DetachAlarm) ManualRun(renv env.Running) (any, error)

func (*DetachAlarm) ParamsSpec 

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

func (*DetachAlarm) Run 

func (cmd *DetachAlarm) Run(renv env.Running, params map[string]any) (any, error)

type DetachClassicLoadbalancer 

type DetachClassicLoadbalancer struct {
	Name     *string `awsName:"LoadBalancerName" awsType:"awsstr" templateName:"name"`
	Instance *string `awsName:"Instances[0]InstanceId" awsType:"awsslicestruct" templateName:"instance"`
	// contains filtered or unexported fields
}

func NewDetachClassicLoadbalancer 

func NewDetachClassicLoadbalancer(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachClassicLoadbalancer

func (*DetachClassicLoadbalancer) ExtractResult 

func (cmd *DetachClassicLoadbalancer) ExtractResult(any) string

func (*DetachClassicLoadbalancer) ParamsSpec 

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

func (*DetachClassicLoadbalancer) Run 

func (cmd *DetachClassicLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type DetachContainertask 

type DetachContainertask struct {
	Name          *string `templateName:"name"`
	ContainerName *string `templateName:"container-name"`
	// contains filtered or unexported fields
}

func NewDetachContainertask 

func NewDetachContainertask(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachContainertask

func (*DetachContainertask) ManualRun 

func (cmd *DetachContainertask) ManualRun(renv env.Running) (any, error)

func (*DetachContainertask) ParamsSpec 

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

func (*DetachContainertask) Run 

func (cmd *DetachContainertask) Run(renv env.Running, params map[string]any) (any, error)

type DetachElasticip 

type DetachElasticip struct {
	Association *string `awsName:"AssociationId" awsType:"awsstr" templateName:"association"`
	// contains filtered or unexported fields
}

func NewDetachElasticip 

func NewDetachElasticip(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachElasticip

func (*DetachElasticip) ParamsSpec 

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

func (*DetachElasticip) Run 

func (cmd *DetachElasticip) Run(renv env.Running, params map[string]any) (any, error)

type DetachEventtarget added in v1.2.0 

type DetachEventtarget struct {
	Rule     *string   `awsName:"Rule" awsType:"awsstr" templateName:"rule"`
	IDs      []*string `awsName:"Ids" awsType:"awsstringslice" templateName:"id"`
	EventBus *string   `awsName:"EventBusName" awsType:"awsstr" templateName:"eventbus"`
	Force    *bool     `awsName:"Force" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDetachEventtarget added in v1.2.0 

func NewDetachEventtarget(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachEventtarget

func (*DetachEventtarget) ParamsSpec added in v1.2.0 

func (cmd *DetachEventtarget) ParamsSpec() params.Spec

func (*DetachEventtarget) Run added in v1.2.0 

func (cmd *DetachEventtarget) Run(renv env.Running, params map[string]any) (any, error)

type DetachInstance 

type DetachInstance struct {
	Targetgroup *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"targetgroup"`
	ID          *string `awsName:"Targets[0]Id" awsType:"awsslicestruct" templateName:"id"`
	// contains filtered or unexported fields
}

func NewDetachInstance 

func NewDetachInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachInstance

func (*DetachInstance) ParamsSpec 

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

func (*DetachInstance) Run 

func (cmd *DetachInstance) Run(renv env.Running, params map[string]any) (any, error)

type DetachInstanceprofile 

type DetachInstanceprofile struct {
	Instance *string `templateName:"instance"`
	Name     *string `templateName:"name"`
	// contains filtered or unexported fields
}

func NewDetachInstanceprofile 

func NewDetachInstanceprofile(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachInstanceprofile

func (*DetachInstanceprofile) ExtractResult 

func (cmd *DetachInstanceprofile) ExtractResult(i any) string

func (*DetachInstanceprofile) ManualRun 

func (cmd *DetachInstanceprofile) ManualRun(renv env.Running) (any, error)

func (*DetachInstanceprofile) ParamsSpec 

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

func (*DetachInstanceprofile) Run 

func (cmd *DetachInstanceprofile) Run(renv env.Running, params map[string]any) (any, error)

type DetachInternetgateway 

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

func NewDetachInternetgateway 

func NewDetachInternetgateway(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachInternetgateway

func (*DetachInternetgateway) ParamsSpec 

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

func (*DetachInternetgateway) Run 

func (cmd *DetachInternetgateway) Run(renv env.Running, params map[string]any) (any, error)

type DetachMfadevice 

type DetachMfadevice struct {
	ID   *string `awsName:"SerialNumber" awsType:"awsstr" templateName:"id"`
	User *string `awsName:"UserName" awsType:"awsstr" templateName:"user"`
	// contains filtered or unexported fields
}

func NewDetachMfadevice 

func NewDetachMfadevice(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachMfadevice

func (*DetachMfadevice) ParamsSpec 

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

func (*DetachMfadevice) Run 

func (cmd *DetachMfadevice) Run(renv env.Running, params map[string]any) (any, 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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachNetworkinterface

func (*DetachNetworkinterface) ManualRun 

func (cmd *DetachNetworkinterface) ManualRun(renv env.Running) (any, error)

func (*DetachNetworkinterface) ParamsSpec 

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

func (*DetachNetworkinterface) Run 

func (cmd *DetachNetworkinterface) Run(renv env.Running, params map[string]any) (any, 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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachPolicy

func (*DetachPolicy) ManualRun 

func (cmd *DetachPolicy) ManualRun(renv env.Running) (any, error)

func (*DetachPolicy) ParamsSpec 

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

func (*DetachPolicy) Run 

func (cmd *DetachPolicy) Run(renv env.Running, params map[string]any) (any, error)

type DetachRole 

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

func NewDetachRole 

func NewDetachRole(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachRole

func (*DetachRole) ParamsSpec 

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

func (*DetachRole) Run 

func (cmd *DetachRole) Run(renv env.Running, params map[string]any) (any, error)

type DetachRoutetable 

type DetachRoutetable struct {
	Association *string `awsName:"AssociationId" awsType:"awsstr" templateName:"association"`
	// contains filtered or unexported fields
}

func NewDetachRoutetable 

func NewDetachRoutetable(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachRoutetable

func (*DetachRoutetable) ParamsSpec 

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

func (*DetachRoutetable) Run 

func (cmd *DetachRoutetable) Run(renv env.Running, params map[string]any) (any, error)

type DetachSecuritygroup 

type DetachSecuritygroup struct {
	ID       *string `templateName:"id"`
	Instance *string `templateName:"instance"`
	// contains filtered or unexported fields
}

func NewDetachSecuritygroup 

func NewDetachSecuritygroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachSecuritygroup

func (*DetachSecuritygroup) ManualRun 

func (cmd *DetachSecuritygroup) ManualRun(renv env.Running) (any, error)

func (*DetachSecuritygroup) ParamsSpec 

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

func (*DetachSecuritygroup) Run 

func (cmd *DetachSecuritygroup) Run(renv env.Running, params map[string]any) (any, error)

type DetachUser 

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

func NewDetachUser 

func NewDetachUser(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachUser

func (*DetachUser) ParamsSpec 

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

func (*DetachUser) Run 

func (cmd *DetachUser) Run(renv env.Running, params map[string]any) (any, error)

type DetachVolume 

type DetachVolume struct {
	Device   *string `awsName:"Device" awsType:"awsstr" templateName:"device"`
	ID       *string `awsName:"VolumeId" awsType:"awsstr" templateName:"id"`
	Instance *string `awsName:"InstanceId" awsType:"awsstr" templateName:"instance"`
	Force    *bool   `awsName:"Force" awsType:"awsbool" templateName:"force"`
	// contains filtered or unexported fields
}

func NewDetachVolume 

func NewDetachVolume(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *DetachVolume

func (*DetachVolume) ExtractResult 

func (cmd *DetachVolume) ExtractResult(i any) string

func (*DetachVolume) ParamsSpec 

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

func (*DetachVolume) Run 

func (cmd *DetachVolume) Run(renv env.Running, params map[string]any) (any, error)

type Distro 

type Distro struct {
	Name, Variant, Arch, Virt, Store string
}

type Factory 

type Factory interface {
	Build(key string) func() any
}
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(context.Context, *ec2.DescribeImagesInput, ...func(*ec2.Options)) (*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

- centos:centos

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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *ImportImage

func (*ImportImage) ExtractResult 

func (cmd *ImportImage) ExtractResult(i any) string

func (*ImportImage) ParamsSpec 

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

func (*ImportImage) Run 

func (cmd *ImportImage) Run(renv env.Running, params map[string]any) (any, error)

type InputPostProcessor 

type InputPostProcessor interface {
	PostProcessInput(any)
}

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 RestartDatabase 

type RestartDatabase struct {
	ID           *string `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"id"`
	WithFailover *bool   `awsName:"ForceFailover" awsType:"awsbool" templateName:"with-failover"`
	// contains filtered or unexported fields
}

func NewRestartDatabase 

func NewRestartDatabase(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *RestartDatabase

func (*RestartDatabase) ParamsSpec 

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

func (*RestartDatabase) Run 

func (cmd *RestartDatabase) Run(renv env.Running, params map[string]any) (any, error)

type RestartInstance 

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

func NewRestartInstance 

func NewRestartInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *RestartInstance

func (*RestartInstance) ParamsSpec 

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

func (*RestartInstance) Run 

func (cmd *RestartInstance) Run(renv env.Running, params map[string]any) (any, error)

type ResultExtractor 

type ResultExtractor interface {
	ExtractResult(any) string
}

type StartAlarm 

type StartAlarm struct {
	Names []*string `awsName:"AlarmNames" awsType:"awsstringslice" templateName:"names"`
	// contains filtered or unexported fields
}

func NewStartAlarm 

func NewStartAlarm(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartAlarm

func (*StartAlarm) ParamsSpec 

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

func (*StartAlarm) Run 

func (cmd *StartAlarm) Run(renv env.Running, params map[string]any) (any, error)

type StartBuildproject added in v1.2.0 

type StartBuildproject struct {
	Name *string `awsName:"ProjectName" awsType:"awsstr" templateName:"name"`
	// Overrides for a one-off build, so a branch or a different buildspec can be built
	// without editing the project.
	SourceVersion  *string `awsName:"SourceVersion" awsType:"awsstr" templateName:"source-version"`
	BuildspecOverr *string `awsName:"BuildspecOverride" awsType:"awsstr" templateName:"buildspec"`
	// contains filtered or unexported fields
}

Builds are started and stopped through the project, the same shape as CodePipeline: a build has no existence until one is started, and the id needed to stop it comes back from the start.

func NewStartBuildproject added in v1.2.0 

func NewStartBuildproject(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartBuildproject

func (*StartBuildproject) ExtractResult added in v1.2.0 

func (cmd *StartBuildproject) ExtractResult(i any) string

func (*StartBuildproject) ParamsSpec added in v1.2.0 

func (cmd *StartBuildproject) ParamsSpec() params.Spec

func (*StartBuildproject) Run added in v1.2.0 

func (cmd *StartBuildproject) Run(renv env.Running, params map[string]any) (any, error)

type StartContainertask 

type StartContainertask struct {
	Cluster                   *string `templateName:"cluster"`
	DesiredCount              *int64  `templateName:"desired-count"`
	Name                      *string `templateName:"name"`
	Type                      *string `templateName:"type"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartContainertask

func (*StartContainertask) ExtractResult 

func (cmd *StartContainertask) ExtractResult(i any) string

func (*StartContainertask) ManualRun 

func (cmd *StartContainertask) ManualRun(renv env.Running) (any, error)

func (*StartContainertask) ParamsSpec 

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

func (*StartContainertask) Run 

func (cmd *StartContainertask) Run(renv env.Running, params map[string]any) (any, error)

type StartCrawler added in v1.2.0 

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

func NewStartCrawler added in v1.2.0 

func NewStartCrawler(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartCrawler

func (*StartCrawler) ParamsSpec added in v1.2.0 

func (cmd *StartCrawler) ParamsSpec() params.Spec

func (*StartCrawler) Run added in v1.2.0 

func (cmd *StartCrawler) Run(renv env.Running, params map[string]any) (any, error)

type StartDatabase 

type StartDatabase struct {
	ID *string `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewStartDatabase 

func NewStartDatabase(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartDatabase

func (*StartDatabase) ParamsSpec 

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

func (*StartDatabase) Run 

func (cmd *StartDatabase) Run(renv env.Running, params map[string]any) (any, error)

type StartEventrule added in v1.2.0 

type StartEventrule struct {
	Name     *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	EventBus *string `awsName:"EventBusName" awsType:"awsstr" templateName:"eventbus"`
	// contains filtered or unexported fields
}

func NewStartEventrule added in v1.2.0 

func NewStartEventrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartEventrule

func (*StartEventrule) ParamsSpec added in v1.2.0 

func (cmd *StartEventrule) ParamsSpec() params.Spec

func (*StartEventrule) Run added in v1.2.0 

func (cmd *StartEventrule) Run(renv env.Running, params map[string]any) (any, error)

type StartExecution added in v1.2.0 

type StartExecution struct {
	StateMachine *string `awsName:"StateMachineArn" awsType:"awsstr" templateName:"statemachine"`
	Name         *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Input        *string `awsName:"Input" awsType:"awsstr" templateName:"input"`
	// contains filtered or unexported fields
}

An execution is started and stopped rather than created and deleted, and is not modeled as a resource: listing executions needs a state machine ARN per call, so it would be an N+1 over every machine on each sync, for run history rather than infrastructure.

func NewStartExecution added in v1.2.0 

func NewStartExecution(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartExecution

func (*StartExecution) ExtractResult added in v1.2.0 

func (cmd *StartExecution) ExtractResult(i any) string

func (*StartExecution) ParamsSpec added in v1.2.0 

func (cmd *StartExecution) ParamsSpec() params.Spec

func (*StartExecution) Run added in v1.2.0 

func (cmd *StartExecution) Run(renv env.Running, params map[string]any) (any, error)

type StartInstance 

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

func NewStartInstance 

func NewStartInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartInstance

func (*StartInstance) ExtractResult 

func (cmd *StartInstance) ExtractResult(i any) string

func (*StartInstance) ParamsSpec 

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

func (*StartInstance) Run 

func (cmd *StartInstance) Run(renv env.Running, params map[string]any) (any, error)

type StartJob added in v1.2.0 

type StartJob struct {
	Name *string `awsName:"JobName" awsType:"awsstr" templateName:"name"`
	// Overrides for one run, so a job can be given more capacity without editing it.
	Workers    *int64  `awsName:"NumberOfWorkers" awsType:"awsint64" templateName:"workers"`
	WorkerType *string `awsName:"WorkerType" awsType:"awsstr" templateName:"worker-type"`
	// contains filtered or unexported fields
}

func NewStartJob added in v1.2.0 

func NewStartJob(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartJob

func (*StartJob) ExtractResult added in v1.2.0 

func (cmd *StartJob) ExtractResult(i any) string

The run id is what identifies this execution afterwards.

func (*StartJob) ParamsSpec added in v1.2.0 

func (cmd *StartJob) ParamsSpec() params.Spec

func (*StartJob) Run added in v1.2.0 

func (cmd *StartJob) Run(renv env.Running, params map[string]any) (any, error)

type StartPipeline added in v1.2.0 

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

func NewStartPipeline added in v1.2.0 

func NewStartPipeline(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartPipeline

func (*StartPipeline) ExtractResult added in v1.2.0 

func (cmd *StartPipeline) ExtractResult(i any) string

The execution id is what `stop pipeline` needs, so it is the useful result.

func (*StartPipeline) ParamsSpec added in v1.2.0 

func (cmd *StartPipeline) ParamsSpec() params.Spec

func (*StartPipeline) Run added in v1.2.0 

func (cmd *StartPipeline) Run(renv env.Running, params map[string]any) (any, error)

type StartTrail 

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

StartTrail begins delivering events. A trail created by create trail is not logging until this runs, which is easy to miss.

func NewStartTrail 

func NewStartTrail(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartTrail

func (*StartTrail) ParamsSpec 

func (cmd *StartTrail) ParamsSpec() params.Spec

func (*StartTrail) Run 

func (cmd *StartTrail) Run(renv env.Running, params map[string]any) (any, error)

type StartVpcpeering added in v1.2.0 

type StartVpcpeering struct {
	ID *string `awsName:"VpcPeeringConnectionId" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

Accepting is spelled `start` rather than `update` because it is a one-way transition with no parameters, not a modification.

func NewStartVpcpeering added in v1.2.0 

func NewStartVpcpeering(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StartVpcpeering

func (*StartVpcpeering) ParamsSpec added in v1.2.0 

func (cmd *StartVpcpeering) ParamsSpec() params.Spec

func (*StartVpcpeering) Run added in v1.2.0 

func (cmd *StartVpcpeering) Run(renv env.Running, params map[string]any) (any, error)

type StopAlarm 

type StopAlarm struct {
	Names []*string `awsName:"AlarmNames" awsType:"awsstringslice" templateName:"names"`
	// contains filtered or unexported fields
}

func NewStopAlarm 

func NewStopAlarm(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopAlarm

func (*StopAlarm) ParamsSpec 

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

func (*StopAlarm) Run 

func (cmd *StopAlarm) Run(renv env.Running, params map[string]any) (any, error)

type StopBuildproject added in v1.2.0 

type StopBuildproject struct {

	// The build id, not the project name: StopBuild addresses a single running build.
	Build *string `awsName:"Id" awsType:"awsstr" templateName:"build"`
	// contains filtered or unexported fields
}

func NewStopBuildproject added in v1.2.0 

func NewStopBuildproject(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopBuildproject

func (*StopBuildproject) ParamsSpec added in v1.2.0 

func (cmd *StopBuildproject) ParamsSpec() params.Spec

func (*StopBuildproject) Run added in v1.2.0 

func (cmd *StopBuildproject) Run(renv env.Running, params map[string]any) (any, error)

type StopContainertask 

type StopContainertask struct {
	Cluster        *string `templateName:"cluster"`
	Type           *string `templateName:"type"`
	DeploymentName *string `templateName:"deployment-name"`
	RunArn         *string `templateName:"run-arn"`
	// contains filtered or unexported fields
}

func NewStopContainertask 

func NewStopContainertask(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopContainertask

func (*StopContainertask) ManualRun 

func (cmd *StopContainertask) ManualRun(renv env.Running) (any, error)

func (*StopContainertask) ParamsSpec 

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

func (*StopContainertask) Run 

func (cmd *StopContainertask) Run(renv env.Running, params map[string]any) (any, error)

type StopCrawler added in v1.2.0 

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

func NewStopCrawler added in v1.2.0 

func NewStopCrawler(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopCrawler

func (*StopCrawler) ParamsSpec added in v1.2.0 

func (cmd *StopCrawler) ParamsSpec() params.Spec

func (*StopCrawler) Run added in v1.2.0 

func (cmd *StopCrawler) Run(renv env.Running, params map[string]any) (any, error)

type StopDatabase 

type StopDatabase struct {
	ID *string `awsName:"DBInstanceIdentifier" awsType:"awsstr" templateName:"id"`
	// contains filtered or unexported fields
}

func NewStopDatabase 

func NewStopDatabase(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopDatabase

func (*StopDatabase) ParamsSpec 

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

func (*StopDatabase) Run 

func (cmd *StopDatabase) Run(renv env.Running, params map[string]any) (any, error)

type StopDeployment added in v1.2.0 

type StopDeployment struct {
	ID           *string `awsName:"DeploymentId" awsType:"awsstr" templateName:"id"`
	AutoRollback *bool   `awsName:"AutoRollbackEnabled" awsType:"awsbool" templateName:"rollback"`
	// contains filtered or unexported fields
}

Stopping a deployment is how a bad rollout is halted, so it is worth having even though there is no delete.

func NewStopDeployment added in v1.2.0 

func NewStopDeployment(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopDeployment

func (*StopDeployment) ParamsSpec added in v1.2.0 

func (cmd *StopDeployment) ParamsSpec() params.Spec

func (*StopDeployment) Run added in v1.2.0 

func (cmd *StopDeployment) Run(renv env.Running, params map[string]any) (any, error)

type StopEventrule added in v1.2.0 

type StopEventrule struct {
	Name     *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	EventBus *string `awsName:"EventBusName" awsType:"awsstr" templateName:"eventbus"`
	// contains filtered or unexported fields
}

func NewStopEventrule added in v1.2.0 

func NewStopEventrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopEventrule

func (*StopEventrule) ParamsSpec added in v1.2.0 

func (cmd *StopEventrule) ParamsSpec() params.Spec

func (*StopEventrule) Run added in v1.2.0 

func (cmd *StopEventrule) Run(renv env.Running, params map[string]any) (any, error)

type StopExecution added in v1.2.0 

type StopExecution struct {
	Arn   *string `awsName:"ExecutionArn" awsType:"awsstr" templateName:"arn"`
	Cause *string `awsName:"Cause" awsType:"awsstr" templateName:"cause"`
	Error *string `awsName:"Error" awsType:"awsstr" templateName:"error"`
	// contains filtered or unexported fields
}

func NewStopExecution added in v1.2.0 

func NewStopExecution(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopExecution

func (*StopExecution) ParamsSpec added in v1.2.0 

func (cmd *StopExecution) ParamsSpec() params.Spec

func (*StopExecution) Run added in v1.2.0 

func (cmd *StopExecution) Run(renv env.Running, params map[string]any) (any, error)

type StopInstance 

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

func NewStopInstance 

func NewStopInstance(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopInstance

func (*StopInstance) ExtractResult 

func (cmd *StopInstance) ExtractResult(i any) string

func (*StopInstance) ParamsSpec 

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

func (*StopInstance) Run 

func (cmd *StopInstance) Run(renv env.Running, params map[string]any) (any, error)

type StopPipeline added in v1.2.0 

type StopPipeline struct {
	Name      *string `awsName:"PipelineName" awsType:"awsstr" templateName:"name"`
	Execution *string `awsName:"PipelineExecutionId" awsType:"awsstr" templateName:"execution"`
	// Abandon stops tracking the execution immediately instead of waiting for
	// in-flight actions to finish, which can leave a deploy half-applied.
	Abandon *bool   `awsName:"Abandon" awsType:"awsbool" templateName:"abandon"`
	Reason  *string `awsName:"Reason" awsType:"awsstr" templateName:"reason"`
	// contains filtered or unexported fields
}

func NewStopPipeline added in v1.2.0 

func NewStopPipeline(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopPipeline

func (*StopPipeline) ParamsSpec added in v1.2.0 

func (cmd *StopPipeline) ParamsSpec() params.Spec

func (*StopPipeline) Run added in v1.2.0 

func (cmd *StopPipeline) Run(renv env.Running, params map[string]any) (any, error)

type StopTrail 

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

func NewStopTrail 

func NewStopTrail(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *StopTrail

func (*StopTrail) ParamsSpec 

func (cmd *StopTrail) ParamsSpec() params.Spec

func (*StopTrail) Run 

func (cmd *StopTrail) Run(renv env.Running, params map[string]any) (any, error)

type UpdateAccelerator added in v1.2.0 

type UpdateAccelerator struct {
	Arn     *string `awsName:"AcceleratorArn" awsType:"awsstr" templateName:"arn"`
	Name    *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Enabled *bool   `awsName:"Enabled" awsType:"awsbool" templateName:"enabled"`
	IPType  *string `awsName:"IpAddressType" awsType:"awsstr" templateName:"ip-type"`
	// contains filtered or unexported fields
}

func NewUpdateAccelerator added in v1.2.0 

func NewUpdateAccelerator(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateAccelerator

func (*UpdateAccelerator) ExtractResult added in v1.2.0 

func (cmd *UpdateAccelerator) ExtractResult(i any) string

func (*UpdateAccelerator) ParamsSpec added in v1.2.0 

func (cmd *UpdateAccelerator) ParamsSpec() params.Spec

func (*UpdateAccelerator) Run added in v1.2.0 

func (cmd *UpdateAccelerator) Run(renv env.Running, params map[string]any) (any, error)

type UpdateApplication added in v1.2.0 

type UpdateApplication struct {
	Name        *string `awsName:"ApplicationName" awsType:"awsstr" templateName:"name"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// contains filtered or unexported fields
}

func NewUpdateApplication added in v1.2.0 

func NewUpdateApplication(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateApplication

func (*UpdateApplication) ExtractResult added in v1.2.0 

func (cmd *UpdateApplication) ExtractResult(i any) string

func (*UpdateApplication) ParamsSpec added in v1.2.0 

func (cmd *UpdateApplication) ParamsSpec() params.Spec

Description is the only mutable field on an application, so it is required rather than optional: an update without it clears the description instead of doing nothing.

func (*UpdateApplication) Run added in v1.2.0 

func (cmd *UpdateApplication) Run(renv env.Running, params map[string]any) (any, error)

type UpdateBucket 

type UpdateBucket struct {
	Name             *string `templateName:"name"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateBucket

func (*UpdateBucket) ManualRun 

func (cmd *UpdateBucket) ManualRun(renv env.Running) (any, error)

func (*UpdateBucket) ParamsSpec 

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

func (*UpdateBucket) Run 

func (cmd *UpdateBucket) Run(renv env.Running, params map[string]any) (any, error)

type UpdateBuildproject added in v1.2.0 

type UpdateBuildproject struct {
	Name           *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Role           *string `awsName:"ServiceRole" awsType:"awsstr" templateName:"role"`
	Description    *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	SourceType     *string `awsName:"Source.Type" awsType:"awsstr" templateName:"source-type"`
	SourceLocation *string `awsName:"Source.Location" awsType:"awsstr" templateName:"source-location"`
	Buildspec      *string `awsName:"Source.Buildspec" awsType:"awsstr" templateName:"buildspec"`
	EnvType        *string `awsName:"Environment.Type" awsType:"awsstr" templateName:"env-type"`
	Image          *string `awsName:"Environment.Image" awsType:"awsstr" templateName:"image"`
	ComputeType    *string `awsName:"Environment.ComputeType" awsType:"awsstr" templateName:"compute-type"`
	Timeout        *int64  `awsName:"TimeoutInMinutes" awsType:"awsint64" templateName:"timeout"`
	// contains filtered or unexported fields
}

UpdateProject leaves omitted fields alone, unlike the put-style updates elsewhere here, so nothing beyond the name is required.

func NewUpdateBuildproject added in v1.2.0 

func NewUpdateBuildproject(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateBuildproject

func (*UpdateBuildproject) ExtractResult added in v1.2.0 

func (cmd *UpdateBuildproject) ExtractResult(i any) string

func (*UpdateBuildproject) ParamsSpec added in v1.2.0 

func (cmd *UpdateBuildproject) ParamsSpec() params.Spec

func (*UpdateBuildproject) Run added in v1.2.0 

func (cmd *UpdateBuildproject) Run(renv env.Running, params map[string]any) (any, error)

type UpdateCachecluster added in v1.2.0 

type UpdateCachecluster struct {
	ID                *string   `awsName:"CacheClusterId" awsType:"awsstr" templateName:"id"`
	Nodes             *int64    `awsName:"NumCacheNodes" awsType:"awsint64" templateName:"nodes"`
	Type              *string   `awsName:"CacheNodeType" awsType:"awsstr" templateName:"type"`
	EngineVersion     *string   `awsName:"EngineVersion" awsType:"awsstr" templateName:"engine-version"`
	Securitygroups    []*string `awsName:"SecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroups"`
	MaintenanceWindow *string   `awsName:"PreferredMaintenanceWindow" awsType:"awsstr" templateName:"maintenance-window"`
	ApplyImmediately  *bool     `awsName:"ApplyImmediately" awsType:"awsbool" templateName:"apply-immediately"`
	// contains filtered or unexported fields
}

func NewUpdateCachecluster added in v1.2.0 

func NewUpdateCachecluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateCachecluster

func (*UpdateCachecluster) ParamsSpec added in v1.2.0 

func (cmd *UpdateCachecluster) ParamsSpec() params.Spec

func (*UpdateCachecluster) Run added in v1.2.0 

func (cmd *UpdateCachecluster) Run(renv env.Running, params map[string]any) (any, error)

type UpdateCachesubnetgroup added in v1.2.0 

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

func NewUpdateCachesubnetgroup added in v1.2.0 

func NewUpdateCachesubnetgroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateCachesubnetgroup

func (*UpdateCachesubnetgroup) ParamsSpec added in v1.2.0 

func (cmd *UpdateCachesubnetgroup) ParamsSpec() params.Spec

func (*UpdateCachesubnetgroup) Run added in v1.2.0 

func (cmd *UpdateCachesubnetgroup) Run(renv env.Running, params map[string]any) (any, error)

type UpdateClassicLoadbalancer 

type UpdateClassicLoadbalancer struct {
	Name                          *string `awsName:"LoadBalancerName" awsType:"awsstr" templateName:"name"`
	HealthcheckHealthyThreshold   *int64  `awsName:"HealthCheck.HealthyThreshold" awsType:"awsint64" templateName:"healthy-threshold"`
	HealthcheckUnhealthyThreshold *int64  `awsName:"HealthCheck.UnhealthyThreshold" awsType:"awsint64" templateName:"unhealthy-threshold"`
	HealthcheckInterval           *int64  `awsName:"HealthCheck.Interval" awsType:"awsint64" templateName:"health-interval"`
	HealthcheckTimeout            *int64  `awsName:"HealthCheck.Timeout" awsType:"awsint64" templateName:"health-timeout"`
	HealthcheckTarget             *string `awsName:"HealthCheck.Target" awsType:"awsstr" templateName:"health-target"`
	// contains filtered or unexported fields
}

func NewUpdateClassicLoadbalancer 

func NewUpdateClassicLoadbalancer(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateClassicLoadbalancer

func (*UpdateClassicLoadbalancer) ParamsSpec 

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

func (*UpdateClassicLoadbalancer) Run 

func (cmd *UpdateClassicLoadbalancer) Run(renv env.Running, params map[string]any) (any, error)

type UpdateConfigrule added in v1.2.0 

type UpdateConfigrule struct {
	Name            *string   `awsName:"ConfigRule.ConfigRuleName" awsType:"awsstr" templateName:"name"`
	Source          *string   `awsName:"ConfigRule.Source.SourceIdentifier" awsType:"awsstr" templateName:"source"`
	Owner           *string   `awsName:"ConfigRule.Source.Owner" awsType:"awsstr" templateName:"owner"`
	Description     *string   `awsName:"ConfigRule.Description" awsType:"awsstr" templateName:"description"`
	InputParameters *string   `awsName:"ConfigRule.InputParameters" awsType:"awsstr" templateName:"input-parameters"`
	Frequency       *string   `awsName:"ConfigRule.MaximumExecutionFrequency" awsType:"awsstr" templateName:"frequency"`
	ResourceTypes   []*string `awsName:"ConfigRule.Scope.ComplianceResourceTypes" awsType:"awsstringslice" templateName:"resource-types"`
	// contains filtered or unexported fields
}

PutConfigRule both creates and replaces, so update maps to the same call. Anything omitted is cleared rather than kept, which is why source stays required here.

func NewUpdateConfigrule added in v1.2.0 

func NewUpdateConfigrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateConfigrule

func (*UpdateConfigrule) ExtractResult added in v1.2.0 

func (cmd *UpdateConfigrule) ExtractResult(i any) string

func (*UpdateConfigrule) ParamsSpec added in v1.2.0 

func (cmd *UpdateConfigrule) ParamsSpec() params.Spec

func (*UpdateConfigrule) Run added in v1.2.0 

func (cmd *UpdateConfigrule) Run(renv env.Running, params map[string]any) (any, error)

type UpdateContainertask 

type UpdateContainertask struct {
	Cluster        *string `awsName:"Cluster" awsType:"awsstr" templateName:"cluster"`
	DeploymentName *string `awsName:"Service" awsType:"awsstr" templateName:"deployment-name"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateContainertask

func (*UpdateContainertask) ParamsSpec 

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

func (*UpdateContainertask) Run 

func (cmd *UpdateContainertask) Run(renv env.Running, params map[string]any) (any, error)

type UpdateDistribution 

type UpdateDistribution struct {
	ID             *string   `awsName:"Id" awsType:"awsstr" templateName:"id"`
	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"`
	HTTPSBehavior  *string   `templateName:"https-behavior"`
	OriginPath     *string   `templateName:"origin-path"`
	PriceClass     *string   `templateName:"price-class"`
	MinTTL         *int64    `templateName:"min-ttl"`
	// contains filtered or unexported fields
}

func NewUpdateDistribution 

func NewUpdateDistribution(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateDistribution

func (*UpdateDistribution) ExtractResult 

func (cmd *UpdateDistribution) ExtractResult(i any) string

func (*UpdateDistribution) ManualRun 

func (cmd *UpdateDistribution) ManualRun(renv env.Running) (any, error)

func (*UpdateDistribution) ParamsSpec 

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

func (*UpdateDistribution) Run 

func (cmd *UpdateDistribution) Run(renv env.Running, params map[string]any) (any, error)

type UpdateEnvironment added in v1.2.0 

type UpdateEnvironment struct {
	Name        *string `awsName:"EnvironmentName" awsType:"awsstr" templateName:"name"`
	Version     *string `awsName:"VersionLabel" awsType:"awsstr" templateName:"version"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	// Changing the platform in place is how a managed platform update is applied.
	SolutionStack *string `awsName:"SolutionStackName" awsType:"awsstr" templateName:"solution-stack"`
	Platform      *string `awsName:"PlatformArn" awsType:"awsstr" templateName:"platform"`
	// contains filtered or unexported fields
}

func NewUpdateEnvironment added in v1.2.0 

func NewUpdateEnvironment(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateEnvironment

func (*UpdateEnvironment) ExtractResult added in v1.2.0 

func (cmd *UpdateEnvironment) ExtractResult(i any) string

func (*UpdateEnvironment) ParamsSpec added in v1.2.0 

func (cmd *UpdateEnvironment) ParamsSpec() params.Spec

Deploying a new version is the common case, so version is suggested; an update naming nothing to change would be a no-op that still triggers an environment update.

func (*UpdateEnvironment) Run added in v1.2.0 

func (cmd *UpdateEnvironment) Run(renv env.Running, params map[string]any) (any, error)

type UpdateEventrule added in v1.2.0 

type UpdateEventrule struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	EventBus    *string `awsName:"EventBusName" awsType:"awsstr" templateName:"eventbus"`
	Pattern     *string `awsName:"EventPattern" awsType:"awsstr" templateName:"pattern"`
	Schedule    *string `awsName:"ScheduleExpression" awsType:"awsstr" templateName:"schedule"`
	Role        *string `awsName:"RoleArn" awsType:"awsstr" templateName:"role"`
	State       *string `awsName:"State" awsType:"awsstr" templateName:"state"`
	// contains filtered or unexported fields
}

func NewUpdateEventrule added in v1.2.0 

func NewUpdateEventrule(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateEventrule

func (*UpdateEventrule) ParamsSpec added in v1.2.0 

func (cmd *UpdateEventrule) ParamsSpec() params.Spec

PutRule replaces the whole rule, so an update that omits the pattern or schedule would silently clear it. One of them stays required for that reason.

func (*UpdateEventrule) Run added in v1.2.0 

func (cmd *UpdateEventrule) Run(renv env.Running, params map[string]any) (any, error)

type UpdateImage 

type UpdateImage struct {
	ID           *string   `awsName:"ImageId" awsType:"awsstr" templateName:"id"`
	Groups       []*string `awsName:"UserGroups" awsType:"awsstringslice" templateName:"groups"`
	Accounts     []*string `awsName:"UserIds" awsType:"awsstringslice" templateName:"accounts"`
	Operation    *string   `awsName:"OperationType" awsType:"awsstr" templateName:"operation"`
	ProductCodes []*string `awsName:"ProductCodes" awsType:"awsstringslice" templateName:"product-codes"`
	Description  *string   `awsName:"Description" awsType:"awsstringattribute" templateName:"description"`
	// contains filtered or unexported fields
}

func NewUpdateImage 

func NewUpdateImage(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateImage

func (*UpdateImage) ManualRun 

func (cmd *UpdateImage) ManualRun(renv env.Running) (any, error)

func (*UpdateImage) ParamsSpec 

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

func (*UpdateImage) Run 

func (cmd *UpdateImage) Run(renv env.Running, params map[string]any) (any, error)

type UpdateInstance 

type UpdateInstance struct {
	ID   *string `awsName:"InstanceId" awsType:"awsstr" templateName:"id"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateInstance

func (*UpdateInstance) ParamsSpec 

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

func (*UpdateInstance) Run 

func (cmd *UpdateInstance) Run(renv env.Running, params map[string]any) (any, error)

type UpdateIpset added in v1.2.0 

type UpdateIpset struct {
	Name        *string   `templateName:"name"`
	Addresses   []*string `templateName:"addresses"`
	Scope       *string   `templateName:"scope"`
	Description *string   `templateName:"description"`
	// contains filtered or unexported fields
}

func NewUpdateIpset added in v1.2.0 

func NewUpdateIpset(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateIpset

func (*UpdateIpset) ManualRun added in v1.2.0 

func (cmd *UpdateIpset) ManualRun(renv env.Running) (any, error)

func (*UpdateIpset) ParamsSpec added in v1.2.0 

func (cmd *UpdateIpset) ParamsSpec() params.Spec

UpdateIPSet replaces the address list outright rather than merging, so addresses stays required — an update without it would empty the set.

func (*UpdateIpset) Run added in v1.2.0 

func (cmd *UpdateIpset) Run(renv env.Running, params map[string]any) (any, error)

type UpdateLoggroup 

type UpdateLoggroup struct {
	Name      *string `awsName:"LogGroupName" awsType:"awsstr" templateName:"name"`
	Retention *int64  `awsName:"RetentionInDays" awsType:"awsint64" templateName:"retention"`
	// contains filtered or unexported fields
}

UpdateLoggroup sets the retention period. Zero means never expire, which the API models as DeleteRetentionPolicy rather than a retention of zero, so that case is handled separately in ManualRun.

func NewUpdateLoggroup 

func NewUpdateLoggroup(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateLoggroup

func (*UpdateLoggroup) ParamsSpec 

func (cmd *UpdateLoggroup) ParamsSpec() params.Spec

func (*UpdateLoggroup) Run 

func (cmd *UpdateLoggroup) Run(renv env.Running, params map[string]any) (any, error)

type UpdateLoginprofile 

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

func NewUpdateLoginprofile 

func NewUpdateLoginprofile(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateLoginprofile

func (*UpdateLoginprofile) ParamsSpec 

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

func (*UpdateLoginprofile) Run 

func (cmd *UpdateLoginprofile) Run(renv env.Running, params map[string]any) (any, error)

type UpdatePolicy 

type UpdatePolicy struct {
	Arn            *string   `awsName:"PolicyArn" awsType:"awsstr" templateName:"arn"`
	Effect         *string   `templateName:"effect"`
	Action         []*string `templateName:"action"`
	Resource       []*string `templateName:"resource"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdatePolicy

func (*UpdatePolicy) BeforeRun 

func (cmd *UpdatePolicy) BeforeRun(renv env.Running) error

func (*UpdatePolicy) ParamsSpec 

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

func (*UpdatePolicy) Run 

func (cmd *UpdatePolicy) Run(renv env.Running, params map[string]any) (any, error)

type UpdateRecord 

type UpdateRecord struct {
	Zone   *string   `templateName:"zone"`
	Name   *string   `templateName:"name"`
	Type   *string   `templateName:"type"`
	Values []*string `templateName:"values"`
	TTL    *int64    `templateName:"ttl"`
	// contains filtered or unexported fields
}

func NewUpdateRecord 

func NewUpdateRecord(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateRecord

func (*UpdateRecord) ExtractResult 

func (cmd *UpdateRecord) ExtractResult(i any) string

func (*UpdateRecord) ManualRun 

func (cmd *UpdateRecord) ManualRun(renv env.Running) (any, error)

func (*UpdateRecord) ParamsSpec 

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

func (*UpdateRecord) Run 

func (cmd *UpdateRecord) Run(renv env.Running, params map[string]any) (any, error)

type UpdateRedshiftcluster added in v1.2.0 

type UpdateRedshiftcluster struct {
	ID             *string   `awsName:"ClusterIdentifier" awsType:"awsstr" templateName:"id"`
	Type           *string   `awsName:"NodeType" awsType:"awsstr" templateName:"type"`
	Nodes          *int64    `awsName:"NumberOfNodes" awsType:"awsint64" templateName:"nodes"`
	ClusterType    *string   `awsName:"ClusterType" awsType:"awsstr" templateName:"cluster-type"`
	Securitygroups []*string `awsName:"VpcSecurityGroupIds" awsType:"awsstringslice" templateName:"securitygroups"`
	Public         *bool     `awsName:"PubliclyAccessible" awsType:"awsbool" templateName:"public"`
	Version        *string   `awsName:"ClusterVersion" awsType:"awsstr" templateName:"version"`
	Password       *string   `awsName:"MasterUserPassword" awsType:"awsstr" templateName:"password"`
	// contains filtered or unexported fields
}

func NewUpdateRedshiftcluster added in v1.2.0 

func NewUpdateRedshiftcluster(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateRedshiftcluster

func (*UpdateRedshiftcluster) ExtractResult added in v1.2.0 

func (cmd *UpdateRedshiftcluster) ExtractResult(i any) string

func (*UpdateRedshiftcluster) ParamsSpec added in v1.2.0 

func (cmd *UpdateRedshiftcluster) ParamsSpec() params.Spec

func (*UpdateRedshiftcluster) Run added in v1.2.0 

func (cmd *UpdateRedshiftcluster) Run(renv env.Running, params map[string]any) (any, error)

type UpdateS3object 

type UpdateS3object struct {
	Bucket  *string `awsName:"Bucket" awsType:"awsstr" templateName:"bucket"`
	Name    *string `awsName:"Key" awsType:"awsstr" templateName:"name"`
	ACL     *string `awsName:"ACL" awsType:"awsstr" templateName:"acl"`
	Version *string `awsName:"VersionId" awsType:"awsstr" templateName:"version"`
	// contains filtered or unexported fields
}

func NewUpdateS3object 

func NewUpdateS3object(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateS3object

func (*UpdateS3object) ParamsSpec 

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

func (*UpdateS3object) Run 

func (cmd *UpdateS3object) Run(renv env.Running, params map[string]any) (any, error)

type UpdateScalinggroup 

type UpdateScalinggroup struct {
	Name                   *string   `awsName:"AutoScalingGroupName" awsType:"awsstr" templateName:"name"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateScalinggroup

func (*UpdateScalinggroup) ParamsSpec 

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

func (*UpdateScalinggroup) Run 

func (cmd *UpdateScalinggroup) Run(renv env.Running, params map[string]any) (any, error)

type UpdateSecret 

type UpdateSecret struct {
	ID          *string `awsName:"SecretId" awsType:"awsstr" templateName:"id"`
	Secret      *string `awsName:"SecretString" awsType:"awsstr" templateName:"secret"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	KmsKey      *string `awsName:"KmsKeyId" awsType:"awsstr" templateName:"kms-key"`
	// contains filtered or unexported fields
}

func NewUpdateSecret 

func NewUpdateSecret(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateSecret

func (*UpdateSecret) ExtractResult 

func (cmd *UpdateSecret) ExtractResult(i any) string

func (*UpdateSecret) ParamsSpec 

func (cmd *UpdateSecret) ParamsSpec() params.Spec

func (*UpdateSecret) Run 

func (cmd *UpdateSecret) Run(renv env.Running, params map[string]any) (any, error)

type UpdateSecuritygroup 

type UpdateSecuritygroup struct {
	ID            *string `templateName:"id"`
	Protocol      *string `templateName:"protocol"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateSecuritygroup

func (*UpdateSecuritygroup) ManualRun 

func (cmd *UpdateSecuritygroup) ManualRun(renv env.Running) (any, error)

func (*UpdateSecuritygroup) ParamsSpec 

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

func (*UpdateSecuritygroup) Run 

func (cmd *UpdateSecuritygroup) Run(renv env.Running, params map[string]any) (any, error)

type UpdateSsmparameter 

type UpdateSsmparameter struct {
	Name        *string `awsName:"Name" awsType:"awsstr" templateName:"name"`
	Value       *string `awsName:"Value" awsType:"awsstr" templateName:"value"`
	Type        *string `awsName:"Type" awsType:"awsstr" templateName:"type"`
	Description *string `awsName:"Description" awsType:"awsstr" templateName:"description"`
	KmsKey      *string `awsName:"KeyId" awsType:"awsstr" templateName:"kms-key"`
	Overwrite   *bool   `awsName:"Overwrite" awsType:"awsbool" templateName:"overwrite"`
	// contains filtered or unexported fields
}

UpdateSsmparameter is PutParameter with Overwrite set, which is how the API models an update — there is no separate operation.

func NewUpdateSsmparameter 

func NewUpdateSsmparameter(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateSsmparameter

func (*UpdateSsmparameter) ExtractResult 

func (cmd *UpdateSsmparameter) ExtractResult(i any) string

func (*UpdateSsmparameter) ParamsSpec 

func (cmd *UpdateSsmparameter) ParamsSpec() params.Spec

func (*UpdateSsmparameter) Run 

func (cmd *UpdateSsmparameter) Run(renv env.Running, params map[string]any) (any, error)

type UpdateStack 

type UpdateStack struct {
	Name                  *string   `awsName:"StackName" awsType:"awsstr" templateName:"name"`
	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"`
	Tags                  []*string `awsName:"Tags" awsType:"awstagslice" templateName:"tags"`
	PolicyBody            *string   `awsName:"StackPolicyBody" awsType:"awsstr"`
	StackFile             *string   `templateName:"stack-file"`
	RollbackTriggers      []*string `awsName:"RollbackConfiguration.RollbackTriggers" awsType:"awsalarmrollbacktriggers" templateName:"rollback-triggers"`
	RollbackMonitoringMin *int64    `awsName:"RollbackConfiguration.MonitoringTimeInMinutes" awsType:"awsint64" templateName:"rollback-monitoring-min"`
	// contains filtered or unexported fields
}

func NewUpdateStack 

func NewUpdateStack(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateStack

func (*UpdateStack) BeforeRun 

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

Add StackFile support via BeforeRun hook https://github.com/bootswithdefer/awless/issues/145 http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html

func (*UpdateStack) ExtractResult 

func (cmd *UpdateStack) ExtractResult(i any) string

func (*UpdateStack) ParamsSpec 

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

func (*UpdateStack) Run 

func (cmd *UpdateStack) Run(renv env.Running, params map[string]any) (any, error)

type UpdateStatemachine added in v1.2.0 

type UpdateStatemachine struct {
	Arn            *string `awsName:"StateMachineArn" awsType:"awsstr" templateName:"arn"`
	Role           *string `awsName:"RoleArn" awsType:"awsstr" templateName:"role"`
	DefinitionFile *string `awsName:"Definition" awsType:"awsfiletostring" templateName:"definition-file"`
	Publish        *bool   `awsName:"Publish" awsType:"awsbool" templateName:"publish"`
	// contains filtered or unexported fields
}

func NewUpdateStatemachine added in v1.2.0 

func NewUpdateStatemachine(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateStatemachine

func (*UpdateStatemachine) ParamsSpec added in v1.2.0 

func (cmd *UpdateStatemachine) ParamsSpec() params.Spec

func (*UpdateStatemachine) Run added in v1.2.0 

func (cmd *UpdateStatemachine) Run(renv env.Running, params map[string]any) (any, error)

type UpdateStream added in v1.2.0 

type UpdateStream struct {
	Name   *string `awsName:"StreamName" awsType:"awsstr" templateName:"name"`
	Shards *int64  `awsName:"TargetShardCount" awsType:"awsint64" templateName:"shards"`
	// Required by the API, and UNIFORM_SCALING is the only value it accepts. Defaulted
	// in BeforeRun rather than asked for, since leaving it unset makes every call fail
	// and there is nothing to choose between.
	ScalingType *string `awsName:"ScalingType" awsType:"awsstr" templateName:"scaling-type"`
	// contains filtered or unexported fields
}

Resharding is the only in-place change worth exposing; retention and encryption each have their own API rather than a general modify call.

func NewUpdateStream added in v1.2.0 

func NewUpdateStream(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateStream

func (*UpdateStream) BeforeRun added in v1.2.0 

func (cmd *UpdateStream) BeforeRun(renv env.Running) error

func (*UpdateStream) ExtractResult added in v1.2.0 

func (cmd *UpdateStream) ExtractResult(i any) string

func (*UpdateStream) ParamsSpec added in v1.2.0 

func (cmd *UpdateStream) ParamsSpec() params.Spec

func (*UpdateStream) Run added in v1.2.0 

func (cmd *UpdateStream) Run(renv env.Running, params map[string]any) (any, error)

type UpdateSubnet 

type UpdateSubnet struct {
	ID     *string `awsName:"SubnetId" awsType:"awsstr" templateName:"id"`
	Public *bool   `awsName:"MapPublicIpOnLaunch" awsType:"awsboolattribute" templateName:"public"`
	// contains filtered or unexported fields
}

func NewUpdateSubnet 

func NewUpdateSubnet(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateSubnet

func (*UpdateSubnet) ParamsSpec 

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

func (*UpdateSubnet) Run 

func (cmd *UpdateSubnet) Run(renv env.Running, params map[string]any) (any, error)

type UpdateTargetgroup 

type UpdateTargetgroup struct {
	ID                  *string `awsName:"TargetGroupArn" awsType:"awsstr" templateName:"id"`
	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(cfg aws.Config, g cloud.GraphAPI, l ...*logger.Logger) *UpdateTargetgroup

func (*UpdateTargetgroup) ManualRun 

func (cmd *UpdateTargetgroup) ManualRun(renv env.Running) (any, error)

func (*UpdateTargetgroup) ParamsSpec 

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

func (*UpdateTargetgroup) Run 

func (cmd *UpdateTargetgroup) Run(renv env.Running, params map[string]any) (any, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.