kec

Documentation

Index

• Constants
• type Kec
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Kec
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kec
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Kec
  • func (c *Kec) AddVmIntoDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AddVmIntoDataGuardRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AddVmIntoDataGuardWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ApplyAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ApplyAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ApplyAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) AttachInstance(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AttachInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AttachInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) AttachInstancesIamRole(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AttachInstancesIamRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AttachInstancesIamRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) AttachKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AttachKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AttachKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) AttachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) AttachNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) AttachNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CalculatePolicyInVolumeNum(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CalculatePolicyInVolumeNumRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CalculatePolicyInVolumeNumWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CalculatePolicyNum(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CalculatePolicyNumRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CalculatePolicyNumWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CancelAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CancelAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CancelAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CopyImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CopyImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CopyImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateDataGuardGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateDataGuardGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateLocalVolumeSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateLocalVolumeSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingNotification(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingNotificationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateScalingNotificationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) CreateScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) CreateScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) CreateScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteDataGuardGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteDataGuardGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteLocalVolumeSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteLocalVolumeSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DeleteScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DeleteScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeAvailabilityZonesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardCapacity(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardCapacityRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeDataGuardCapacityWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeDataGuardGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeDataGuardGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImageSharePermissionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeImageSharePermissionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImages(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeImagesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceFamilys(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceFamilysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstanceFamilysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceTypeConfigs(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceTypeConfigsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstanceTypeConfigsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceVnc(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstanceVncRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstanceVncWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeKecIamRoles(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeKecIamRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeKecIamRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeKecInventory(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeKecInventoryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeKecInventoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumeSnapshots(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumeSnapshotsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeLocalVolumeSnapshotsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumes(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeLocalVolumesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeLocalVolumesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeRegions(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeRegionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeRegionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingActivity(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingActivityRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeScalingActivityWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingInstance(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeScalingInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingNotification(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingNotificationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeScalingNotificationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DescribeScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DescribeScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DetachInstance(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DetachInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DetachInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DetachInstancesIamRole(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DetachInstancesIamRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DetachInstancesIamRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DetachKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DetachKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DetachKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DetachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DetachNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DetachNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) DisableScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) DisableScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) DisableScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) EnableImageCaching(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) EnableImageCachingRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) EnableImageCachingWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) EnableScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) EnableScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) EnableScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ImportImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ImportImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ImportImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyDataGuardGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyDataGuardGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageAttribute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyImageAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyImageSharePermissionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyImageSharePermissionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyInstanceAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceImage(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyInstanceImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceType(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyInstanceTypeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyInstanceTypeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyNetworkInterfaceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyNetworkInterfaceAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyNetworkInterfaceAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingLoadBalancers(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingLoadBalancersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyScalingLoadBalancersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingNotification(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingNotificationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyScalingNotificationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) ModifyScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) ModifyScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RebootInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RebootInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RebootInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RemoveImages(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RemoveImagesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RemoveImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RemoveVmFromDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RemoveVmFromDataGuardRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RemoveVmFromDataGuardWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RollbackLocalVolume(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RollbackLocalVolumeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RollbackLocalVolumeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) RunInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) RunInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) RunInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) SetKvmProtectedDetach(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) SetKvmProtectedDetachRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) SetKvmProtectedDetachWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) StartInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) StartInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) StartInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) StopInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) StopInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) StopInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Kec) TerminateInstances(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Kec) TerminateInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Kec) TerminateInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

const (
	ServiceName = "kec"       // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "kec"       // ServiceID is a unique identifer of a specific service.
)

Service information constants

Types

type Kec

type Kec struct {
	*client.Client
}

Kec provides the API operation methods for making requests to kec. See this package's package overview docs for details on the service.

Kec methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Kec

extraNew create int can support ssl or region locate set

func New

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kec

New creates a new instance of the Kec client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Kec client from just a session.
svc := kec.New(mySession)

// Create a Kec client with additional configuration
svc := kec.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Kec

SdkNew create int can support ssl or region locate set

func (*Kec) AddVmIntoDataGuard

func (c *Kec) AddVmIntoDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)

AddVmIntoDataGuard API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation AddVmIntoDataGuard for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AddVmIntoDataGuard

func (*Kec) AddVmIntoDataGuardRequest

func (c *Kec) AddVmIntoDataGuardRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddVmIntoDataGuardRequest generates a "ksc/request.Request" representing the client's request for the AddVmIntoDataGuard operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddVmIntoDataGuard for more information on using the AddVmIntoDataGuard API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddVmIntoDataGuardRequest method.
req, resp := client.AddVmIntoDataGuardRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AddVmIntoDataGuard

func (*Kec) AddVmIntoDataGuardWithContext

func (c *Kec) AddVmIntoDataGuardWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddVmIntoDataGuardWithContext is the same as AddVmIntoDataGuard with the addition of the ability to pass a context and additional request options.

See AddVmIntoDataGuard for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ApplyAutoSnapshotPolicy

func (c *Kec) ApplyAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ApplyAutoSnapshotPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ApplyAutoSnapshotPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ApplyAutoSnapshotPolicy

func (*Kec) ApplyAutoSnapshotPolicyRequest

func (c *Kec) ApplyAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ApplyAutoSnapshotPolicyRequest generates a "ksc/request.Request" representing the client's request for the ApplyAutoSnapshotPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ApplyAutoSnapshotPolicy for more information on using the ApplyAutoSnapshotPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ApplyAutoSnapshotPolicyRequest method.
req, resp := client.ApplyAutoSnapshotPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ApplyAutoSnapshotPolicy

func (*Kec) ApplyAutoSnapshotPolicyWithContext

func (c *Kec) ApplyAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ApplyAutoSnapshotPolicyWithContext is the same as ApplyAutoSnapshotPolicy with the addition of the ability to pass a context and additional request options.

See ApplyAutoSnapshotPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) AttachInstance

func (c *Kec) AttachInstance(input *map[string]interface{}) (*map[string]interface{}, error)

AttachInstance API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation AttachInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachInstance

func (*Kec) AttachInstanceRequest

func (c *Kec) AttachInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachInstanceRequest generates a "ksc/request.Request" representing the client's request for the AttachInstance operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachInstance for more information on using the AttachInstance API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachInstanceRequest method.
req, resp := client.AttachInstanceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachInstance

func (*Kec) AttachInstanceWithContext

func (c *Kec) AttachInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachInstanceWithContext is the same as AttachInstance with the addition of the ability to pass a context and additional request options.

See AttachInstance for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) AttachInstancesIamRole

func (c *Kec) AttachInstancesIamRole(input *map[string]interface{}) (*map[string]interface{}, error)

AttachInstancesIamRole API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation AttachInstancesIamRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachInstancesIamRole

func (*Kec) AttachInstancesIamRoleRequest

func (c *Kec) AttachInstancesIamRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachInstancesIamRoleRequest generates a "ksc/request.Request" representing the client's request for the AttachInstancesIamRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachInstancesIamRole for more information on using the AttachInstancesIamRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachInstancesIamRoleRequest method.
req, resp := client.AttachInstancesIamRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachInstancesIamRole

func (*Kec) AttachInstancesIamRoleWithContext

func (c *Kec) AttachInstancesIamRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachInstancesIamRoleWithContext is the same as AttachInstancesIamRole with the addition of the ability to pass a context and additional request options.

See AttachInstancesIamRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) AttachKey

func (c *Kec) AttachKey(input *map[string]interface{}) (*map[string]interface{}, error)

AttachKey API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation AttachKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachKey

func (*Kec) AttachKeyRequest

func (c *Kec) AttachKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachKeyRequest generates a "ksc/request.Request" representing the client's request for the AttachKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachKey for more information on using the AttachKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachKeyRequest method.
req, resp := client.AttachKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachKey

func (*Kec) AttachKeyWithContext

func (c *Kec) AttachKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachKeyWithContext is the same as AttachKey with the addition of the ability to pass a context and additional request options.

See AttachKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) AttachNetworkInterface

func (c *Kec) AttachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)

AttachNetworkInterface API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation AttachNetworkInterface for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachNetworkInterface

func (*Kec) AttachNetworkInterfaceRequest

func (c *Kec) AttachNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachNetworkInterfaceRequest generates a "ksc/request.Request" representing the client's request for the AttachNetworkInterface operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachNetworkInterface for more information on using the AttachNetworkInterface API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachNetworkInterfaceRequest method.
req, resp := client.AttachNetworkInterfaceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/AttachNetworkInterface

func (*Kec) AttachNetworkInterfaceWithContext

func (c *Kec) AttachNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachNetworkInterfaceWithContext is the same as AttachNetworkInterface with the addition of the ability to pass a context and additional request options.

See AttachNetworkInterface for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CalculatePolicyInVolumeNum

func (c *Kec) CalculatePolicyInVolumeNum(input *map[string]interface{}) (*map[string]interface{}, error)

CalculatePolicyInVolumeNum API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CalculatePolicyInVolumeNum for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CalculatePolicyInVolumeNum

func (*Kec) CalculatePolicyInVolumeNumRequest

func (c *Kec) CalculatePolicyInVolumeNumRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CalculatePolicyInVolumeNumRequest generates a "ksc/request.Request" representing the client's request for the CalculatePolicyInVolumeNum operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CalculatePolicyInVolumeNum for more information on using the CalculatePolicyInVolumeNum API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CalculatePolicyInVolumeNumRequest method.
req, resp := client.CalculatePolicyInVolumeNumRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CalculatePolicyInVolumeNum

func (*Kec) CalculatePolicyInVolumeNumWithContext

func (c *Kec) CalculatePolicyInVolumeNumWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CalculatePolicyInVolumeNumWithContext is the same as CalculatePolicyInVolumeNum with the addition of the ability to pass a context and additional request options.

See CalculatePolicyInVolumeNum for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CalculatePolicyNum

func (c *Kec) CalculatePolicyNum(input *map[string]interface{}) (*map[string]interface{}, error)

CalculatePolicyNum API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CalculatePolicyNum for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CalculatePolicyNum

func (*Kec) CalculatePolicyNumRequest

func (c *Kec) CalculatePolicyNumRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CalculatePolicyNumRequest generates a "ksc/request.Request" representing the client's request for the CalculatePolicyNum operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CalculatePolicyNum for more information on using the CalculatePolicyNum API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CalculatePolicyNumRequest method.
req, resp := client.CalculatePolicyNumRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CalculatePolicyNum

func (*Kec) CalculatePolicyNumWithContext

func (c *Kec) CalculatePolicyNumWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CalculatePolicyNumWithContext is the same as CalculatePolicyNum with the addition of the ability to pass a context and additional request options.

See CalculatePolicyNum for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CancelAutoSnapshotPolicy

func (c *Kec) CancelAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

CancelAutoSnapshotPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CancelAutoSnapshotPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CancelAutoSnapshotPolicy

func (*Kec) CancelAutoSnapshotPolicyRequest

func (c *Kec) CancelAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CancelAutoSnapshotPolicyRequest generates a "ksc/request.Request" representing the client's request for the CancelAutoSnapshotPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CancelAutoSnapshotPolicy for more information on using the CancelAutoSnapshotPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CancelAutoSnapshotPolicyRequest method.
req, resp := client.CancelAutoSnapshotPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CancelAutoSnapshotPolicy

func (*Kec) CancelAutoSnapshotPolicyWithContext

func (c *Kec) CancelAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CancelAutoSnapshotPolicyWithContext is the same as CancelAutoSnapshotPolicy with the addition of the ability to pass a context and additional request options.

See CancelAutoSnapshotPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CopyImage

func (c *Kec) CopyImage(input *map[string]interface{}) (*map[string]interface{}, error)

CopyImage API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CopyImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CopyImage

func (*Kec) CopyImageRequest

func (c *Kec) CopyImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CopyImageRequest generates a "ksc/request.Request" representing the client's request for the CopyImage operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CopyImage for more information on using the CopyImage API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CopyImageRequest method.
req, resp := client.CopyImageRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CopyImage

func (*Kec) CopyImageWithContext

func (c *Kec) CopyImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CopyImageWithContext is the same as CopyImage with the addition of the ability to pass a context and additional request options.

See CopyImage for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateAutoSnapshotPolicy

func (c *Kec) CreateAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

CreateAutoSnapshotPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateAutoSnapshotPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateAutoSnapshotPolicy

func (*Kec) CreateAutoSnapshotPolicyRequest

func (c *Kec) CreateAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateAutoSnapshotPolicyRequest generates a "ksc/request.Request" representing the client's request for the CreateAutoSnapshotPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateAutoSnapshotPolicy for more information on using the CreateAutoSnapshotPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateAutoSnapshotPolicyRequest method.
req, resp := client.CreateAutoSnapshotPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateAutoSnapshotPolicy

func (*Kec) CreateAutoSnapshotPolicyWithContext

func (c *Kec) CreateAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateAutoSnapshotPolicyWithContext is the same as CreateAutoSnapshotPolicy with the addition of the ability to pass a context and additional request options.

See CreateAutoSnapshotPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateDataGuardGroup

func (c *Kec) CreateDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)

CreateDataGuardGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateDataGuardGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateDataGuardGroup

func (*Kec) CreateDataGuardGroupRequest

func (c *Kec) CreateDataGuardGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateDataGuardGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateDataGuardGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateDataGuardGroup for more information on using the CreateDataGuardGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateDataGuardGroupRequest method.
req, resp := client.CreateDataGuardGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateDataGuardGroup

func (*Kec) CreateDataGuardGroupWithContext

func (c *Kec) CreateDataGuardGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateDataGuardGroupWithContext is the same as CreateDataGuardGroup with the addition of the ability to pass a context and additional request options.

See CreateDataGuardGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateImage

func (c *Kec) CreateImage(input *map[string]interface{}) (*map[string]interface{}, error)

CreateImage API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateImage

func (*Kec) CreateImageRequest

func (c *Kec) CreateImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateImageRequest generates a "ksc/request.Request" representing the client's request for the CreateImage operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateImage for more information on using the CreateImage API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateImageRequest method.
req, resp := client.CreateImageRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateImage

func (*Kec) CreateImageWithContext

func (c *Kec) CreateImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateImageWithContext is the same as CreateImage with the addition of the ability to pass a context and additional request options.

See CreateImage for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateLocalVolumeSnapshot

func (c *Kec) CreateLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLocalVolumeSnapshot API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateLocalVolumeSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateLocalVolumeSnapshot

func (*Kec) CreateLocalVolumeSnapshotRequest

func (c *Kec) CreateLocalVolumeSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateLocalVolumeSnapshotRequest generates a "ksc/request.Request" representing the client's request for the CreateLocalVolumeSnapshot operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateLocalVolumeSnapshot for more information on using the CreateLocalVolumeSnapshot API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateLocalVolumeSnapshotRequest method.
req, resp := client.CreateLocalVolumeSnapshotRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateLocalVolumeSnapshot

func (*Kec) CreateLocalVolumeSnapshotWithContext

func (c *Kec) CreateLocalVolumeSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateLocalVolumeSnapshotWithContext is the same as CreateLocalVolumeSnapshot with the addition of the ability to pass a context and additional request options.

See CreateLocalVolumeSnapshot for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateScalingConfiguration

func (c *Kec) CreateScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScalingConfiguration API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateScalingConfiguration for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingConfiguration

func (*Kec) CreateScalingConfigurationRequest

func (c *Kec) CreateScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateScalingConfigurationRequest generates a "ksc/request.Request" representing the client's request for the CreateScalingConfiguration operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateScalingConfiguration for more information on using the CreateScalingConfiguration API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateScalingConfigurationRequest method.
req, resp := client.CreateScalingConfigurationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingConfiguration

func (*Kec) CreateScalingConfigurationWithContext

func (c *Kec) CreateScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateScalingConfigurationWithContext is the same as CreateScalingConfiguration with the addition of the ability to pass a context and additional request options.

See CreateScalingConfiguration for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateScalingGroup

func (c *Kec) CreateScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScalingGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateScalingGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingGroup

func (*Kec) CreateScalingGroupRequest

func (c *Kec) CreateScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateScalingGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateScalingGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateScalingGroup for more information on using the CreateScalingGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateScalingGroupRequest method.
req, resp := client.CreateScalingGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingGroup

func (*Kec) CreateScalingGroupWithContext

func (c *Kec) CreateScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateScalingGroupWithContext is the same as CreateScalingGroup with the addition of the ability to pass a context and additional request options.

See CreateScalingGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateScalingNotification

func (c *Kec) CreateScalingNotification(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScalingNotification API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateScalingNotification for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingNotification

func (*Kec) CreateScalingNotificationRequest

func (c *Kec) CreateScalingNotificationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateScalingNotificationRequest generates a "ksc/request.Request" representing the client's request for the CreateScalingNotification operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateScalingNotification for more information on using the CreateScalingNotification API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateScalingNotificationRequest method.
req, resp := client.CreateScalingNotificationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingNotification

func (*Kec) CreateScalingNotificationWithContext

func (c *Kec) CreateScalingNotificationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateScalingNotificationWithContext is the same as CreateScalingNotification with the addition of the ability to pass a context and additional request options.

See CreateScalingNotification for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateScalingPolicy

func (c *Kec) CreateScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScalingPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateScalingPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingPolicy

func (*Kec) CreateScalingPolicyRequest

func (c *Kec) CreateScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateScalingPolicyRequest generates a "ksc/request.Request" representing the client's request for the CreateScalingPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateScalingPolicy for more information on using the CreateScalingPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateScalingPolicyRequest method.
req, resp := client.CreateScalingPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScalingPolicy

func (*Kec) CreateScalingPolicyWithContext

func (c *Kec) CreateScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateScalingPolicyWithContext is the same as CreateScalingPolicy with the addition of the ability to pass a context and additional request options.

See CreateScalingPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) CreateScheduledTask

func (c *Kec) CreateScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)

CreateScheduledTask API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation CreateScheduledTask for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScheduledTask

func (*Kec) CreateScheduledTaskRequest

func (c *Kec) CreateScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateScheduledTaskRequest generates a "ksc/request.Request" representing the client's request for the CreateScheduledTask operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateScheduledTask for more information on using the CreateScheduledTask API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateScheduledTaskRequest method.
req, resp := client.CreateScheduledTaskRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/CreateScheduledTask

func (*Kec) CreateScheduledTaskWithContext

func (c *Kec) CreateScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateScheduledTaskWithContext is the same as CreateScheduledTask with the addition of the ability to pass a context and additional request options.

See CreateScheduledTask for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DeleteAutoSnapshotPolicy

func (c *Kec) DeleteAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteAutoSnapshotPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DeleteAutoSnapshotPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteAutoSnapshotPolicy

func (*Kec) DeleteAutoSnapshotPolicyRequest

func (c *Kec) DeleteAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteAutoSnapshotPolicyRequest generates a "ksc/request.Request" representing the client's request for the DeleteAutoSnapshotPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteAutoSnapshotPolicy for more information on using the DeleteAutoSnapshotPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteAutoSnapshotPolicyRequest method.
req, resp := client.DeleteAutoSnapshotPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteAutoSnapshotPolicy

func (*Kec) DeleteAutoSnapshotPolicyWithContext

func (c *Kec) DeleteAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteAutoSnapshotPolicyWithContext is the same as DeleteAutoSnapshotPolicy with the addition of the ability to pass a context and additional request options.

See DeleteAutoSnapshotPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DeleteDataGuardGroups

func (c *Kec) DeleteDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteDataGuardGroups API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DeleteDataGuardGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteDataGuardGroups

func (*Kec) DeleteDataGuardGroupsRequest

func (c *Kec) DeleteDataGuardGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteDataGuardGroupsRequest generates a "ksc/request.Request" representing the client's request for the DeleteDataGuardGroups operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteDataGuardGroups for more information on using the DeleteDataGuardGroups API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteDataGuardGroupsRequest method.
req, resp := client.DeleteDataGuardGroupsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteDataGuardGroups

func (*Kec) DeleteDataGuardGroupsWithContext

func (c *Kec) DeleteDataGuardGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteDataGuardGroupsWithContext is the same as DeleteDataGuardGroups with the addition of the ability to pass a context and additional request options.

See DeleteDataGuardGroups for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DeleteLocalVolumeSnapshot

func (c *Kec) DeleteLocalVolumeSnapshot(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLocalVolumeSnapshot API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DeleteLocalVolumeSnapshot for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteLocalVolumeSnapshot

func (*Kec) DeleteLocalVolumeSnapshotRequest

func (c *Kec) DeleteLocalVolumeSnapshotRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteLocalVolumeSnapshotRequest generates a "ksc/request.Request" representing the client's request for the DeleteLocalVolumeSnapshot operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteLocalVolumeSnapshot for more information on using the DeleteLocalVolumeSnapshot API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteLocalVolumeSnapshotRequest method.
req, resp := client.DeleteLocalVolumeSnapshotRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteLocalVolumeSnapshot

func (*Kec) DeleteLocalVolumeSnapshotWithContext

func (c *Kec) DeleteLocalVolumeSnapshotWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteLocalVolumeSnapshotWithContext is the same as DeleteLocalVolumeSnapshot with the addition of the ability to pass a context and additional request options.

See DeleteLocalVolumeSnapshot for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DeleteScalingConfiguration

func (c *Kec) DeleteScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteScalingConfiguration API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DeleteScalingConfiguration for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScalingConfiguration

func (*Kec) DeleteScalingConfigurationRequest

func (c *Kec) DeleteScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteScalingConfigurationRequest generates a "ksc/request.Request" representing the client's request for the DeleteScalingConfiguration operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteScalingConfiguration for more information on using the DeleteScalingConfiguration API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteScalingConfigurationRequest method.
req, resp := client.DeleteScalingConfigurationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScalingConfiguration

func (*Kec) DeleteScalingConfigurationWithContext

func (c *Kec) DeleteScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteScalingConfigurationWithContext is the same as DeleteScalingConfiguration with the addition of the ability to pass a context and additional request options.

See DeleteScalingConfiguration for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DeleteScalingGroup

func (c *Kec) DeleteScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteScalingGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DeleteScalingGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScalingGroup

func (*Kec) DeleteScalingGroupRequest

func (c *Kec) DeleteScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteScalingGroupRequest generates a "ksc/request.Request" representing the client's request for the DeleteScalingGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteScalingGroup for more information on using the DeleteScalingGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteScalingGroupRequest method.
req, resp := client.DeleteScalingGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScalingGroup

func (*Kec) DeleteScalingGroupWithContext

func (c *Kec) DeleteScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteScalingGroupWithContext is the same as DeleteScalingGroup with the addition of the ability to pass a context and additional request options.

See DeleteScalingGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DeleteScalingPolicy

func (c *Kec) DeleteScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteScalingPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DeleteScalingPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScalingPolicy

func (*Kec) DeleteScalingPolicyRequest

func (c *Kec) DeleteScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteScalingPolicyRequest generates a "ksc/request.Request" representing the client's request for the DeleteScalingPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteScalingPolicy for more information on using the DeleteScalingPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteScalingPolicyRequest method.
req, resp := client.DeleteScalingPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScalingPolicy

func (*Kec) DeleteScalingPolicyWithContext

func (c *Kec) DeleteScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteScalingPolicyWithContext is the same as DeleteScalingPolicy with the addition of the ability to pass a context and additional request options.

See DeleteScalingPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DeleteScheduledTask

func (c *Kec) DeleteScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteScheduledTask API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DeleteScheduledTask for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScheduledTask

func (*Kec) DeleteScheduledTaskRequest

func (c *Kec) DeleteScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteScheduledTaskRequest generates a "ksc/request.Request" representing the client's request for the DeleteScheduledTask operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteScheduledTask for more information on using the DeleteScheduledTask API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteScheduledTaskRequest method.
req, resp := client.DeleteScheduledTaskRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DeleteScheduledTask

func (*Kec) DeleteScheduledTaskWithContext

func (c *Kec) DeleteScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteScheduledTaskWithContext is the same as DeleteScheduledTask with the addition of the ability to pass a context and additional request options.

See DeleteScheduledTask for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeAutoSnapshotPolicy

func (c *Kec) DescribeAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAutoSnapshotPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeAutoSnapshotPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeAutoSnapshotPolicy

func (*Kec) DescribeAutoSnapshotPolicyRequest

func (c *Kec) DescribeAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeAutoSnapshotPolicyRequest generates a "ksc/request.Request" representing the client's request for the DescribeAutoSnapshotPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeAutoSnapshotPolicy for more information on using the DescribeAutoSnapshotPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeAutoSnapshotPolicyRequest method.
req, resp := client.DescribeAutoSnapshotPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeAutoSnapshotPolicy

func (*Kec) DescribeAutoSnapshotPolicyWithContext

func (c *Kec) DescribeAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeAutoSnapshotPolicyWithContext is the same as DescribeAutoSnapshotPolicy with the addition of the ability to pass a context and additional request options.

See DescribeAutoSnapshotPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeAvailabilityZones

func (c *Kec) DescribeAvailabilityZones(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeAvailabilityZones API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeAvailabilityZones for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeAvailabilityZones

func (*Kec) DescribeAvailabilityZonesRequest

func (c *Kec) DescribeAvailabilityZonesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeAvailabilityZonesRequest generates a "ksc/request.Request" representing the client's request for the DescribeAvailabilityZones operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeAvailabilityZones for more information on using the DescribeAvailabilityZones API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeAvailabilityZonesRequest method.
req, resp := client.DescribeAvailabilityZonesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeAvailabilityZones

func (*Kec) DescribeAvailabilityZonesWithContext

func (c *Kec) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeAvailabilityZonesWithContext is the same as DescribeAvailabilityZones with the addition of the ability to pass a context and additional request options.

See DescribeAvailabilityZones for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeDataGuardCapacity

func (c *Kec) DescribeDataGuardCapacity(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDataGuardCapacity API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeDataGuardCapacity for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardCapacity

func (*Kec) DescribeDataGuardCapacityRequest

func (c *Kec) DescribeDataGuardCapacityRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeDataGuardCapacityRequest generates a "ksc/request.Request" representing the client's request for the DescribeDataGuardCapacity operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeDataGuardCapacity for more information on using the DescribeDataGuardCapacity API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeDataGuardCapacityRequest method.
req, resp := client.DescribeDataGuardCapacityRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardCapacity

func (*Kec) DescribeDataGuardCapacityWithContext

func (c *Kec) DescribeDataGuardCapacityWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeDataGuardCapacityWithContext is the same as DescribeDataGuardCapacity with the addition of the ability to pass a context and additional request options.

See DescribeDataGuardCapacity for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeDataGuardGroup

func (c *Kec) DescribeDataGuardGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeDataGuardGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeDataGuardGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardGroup

func (*Kec) DescribeDataGuardGroupRequest

func (c *Kec) DescribeDataGuardGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeDataGuardGroupRequest generates a "ksc/request.Request" representing the client's request for the DescribeDataGuardGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeDataGuardGroup for more information on using the DescribeDataGuardGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeDataGuardGroupRequest method.
req, resp := client.DescribeDataGuardGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeDataGuardGroup

func (*Kec) DescribeDataGuardGroupWithContext

func (c *Kec) DescribeDataGuardGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeDataGuardGroupWithContext is the same as DescribeDataGuardGroup with the addition of the ability to pass a context and additional request options.

See DescribeDataGuardGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeImageSharePermission

func (c *Kec) DescribeImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeImageSharePermission API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeImageSharePermission for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImageSharePermission

func (*Kec) DescribeImageSharePermissionRequest

func (c *Kec) DescribeImageSharePermissionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeImageSharePermissionRequest generates a "ksc/request.Request" representing the client's request for the DescribeImageSharePermission operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeImageSharePermission for more information on using the DescribeImageSharePermission API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeImageSharePermissionRequest method.
req, resp := client.DescribeImageSharePermissionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImageSharePermission

func (*Kec) DescribeImageSharePermissionWithContext

func (c *Kec) DescribeImageSharePermissionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeImageSharePermissionWithContext is the same as DescribeImageSharePermission with the addition of the ability to pass a context and additional request options.

See DescribeImageSharePermission for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeImages

func (c *Kec) DescribeImages(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeImages API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeImages for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImages

func (*Kec) DescribeImagesRequest

func (c *Kec) DescribeImagesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeImagesRequest generates a "ksc/request.Request" representing the client's request for the DescribeImages operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeImages for more information on using the DescribeImages API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeImagesRequest method.
req, resp := client.DescribeImagesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeImages

func (*Kec) DescribeImagesWithContext

func (c *Kec) DescribeImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeImagesWithContext is the same as DescribeImages with the addition of the ability to pass a context and additional request options.

See DescribeImages for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeInstanceFamilys

func (c *Kec) DescribeInstanceFamilys(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceFamilys API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeInstanceFamilys for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceFamilys

func (*Kec) DescribeInstanceFamilysRequest

func (c *Kec) DescribeInstanceFamilysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeInstanceFamilysRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstanceFamilys operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeInstanceFamilys for more information on using the DescribeInstanceFamilys API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeInstanceFamilysRequest method.
req, resp := client.DescribeInstanceFamilysRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceFamilys

func (*Kec) DescribeInstanceFamilysWithContext

func (c *Kec) DescribeInstanceFamilysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeInstanceFamilysWithContext is the same as DescribeInstanceFamilys with the addition of the ability to pass a context and additional request options.

See DescribeInstanceFamilys for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeInstanceTypeConfigs

func (c *Kec) DescribeInstanceTypeConfigs(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceTypeConfigs API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeInstanceTypeConfigs for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceTypeConfigs

func (*Kec) DescribeInstanceTypeConfigsRequest

func (c *Kec) DescribeInstanceTypeConfigsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeInstanceTypeConfigsRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstanceTypeConfigs operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeInstanceTypeConfigs for more information on using the DescribeInstanceTypeConfigs API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeInstanceTypeConfigsRequest method.
req, resp := client.DescribeInstanceTypeConfigsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceTypeConfigs

func (*Kec) DescribeInstanceTypeConfigsWithContext

func (c *Kec) DescribeInstanceTypeConfigsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeInstanceTypeConfigsWithContext is the same as DescribeInstanceTypeConfigs with the addition of the ability to pass a context and additional request options.

See DescribeInstanceTypeConfigs for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeInstanceVnc

func (c *Kec) DescribeInstanceVnc(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstanceVnc API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeInstanceVnc for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceVnc

func (*Kec) DescribeInstanceVncRequest

func (c *Kec) DescribeInstanceVncRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeInstanceVncRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstanceVnc operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeInstanceVnc for more information on using the DescribeInstanceVnc API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeInstanceVncRequest method.
req, resp := client.DescribeInstanceVncRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstanceVnc

func (*Kec) DescribeInstanceVncWithContext

func (c *Kec) DescribeInstanceVncWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeInstanceVncWithContext is the same as DescribeInstanceVnc with the addition of the ability to pass a context and additional request options.

See DescribeInstanceVnc for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeInstances

func (c *Kec) DescribeInstances(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeInstances API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstances

func (*Kec) DescribeInstancesRequest

func (c *Kec) DescribeInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeInstancesRequest generates a "ksc/request.Request" representing the client's request for the DescribeInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeInstances for more information on using the DescribeInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeInstancesRequest method.
req, resp := client.DescribeInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeInstances

func (*Kec) DescribeInstancesWithContext

func (c *Kec) DescribeInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeInstancesWithContext is the same as DescribeInstances with the addition of the ability to pass a context and additional request options.

See DescribeInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeKecIamRoles

func (c *Kec) DescribeKecIamRoles(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeKecIamRoles API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeKecIamRoles for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeKecIamRoles

func (*Kec) DescribeKecIamRolesRequest

func (c *Kec) DescribeKecIamRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeKecIamRolesRequest generates a "ksc/request.Request" representing the client's request for the DescribeKecIamRoles operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeKecIamRoles for more information on using the DescribeKecIamRoles API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeKecIamRolesRequest method.
req, resp := client.DescribeKecIamRolesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeKecIamRoles

func (*Kec) DescribeKecIamRolesWithContext

func (c *Kec) DescribeKecIamRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeKecIamRolesWithContext is the same as DescribeKecIamRoles with the addition of the ability to pass a context and additional request options.

See DescribeKecIamRoles for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeKecInventory

func (c *Kec) DescribeKecInventory(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeKecInventory API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeKecInventory for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeKecInventory

func (*Kec) DescribeKecInventoryRequest

func (c *Kec) DescribeKecInventoryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeKecInventoryRequest generates a "ksc/request.Request" representing the client's request for the DescribeKecInventory operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeKecInventory for more information on using the DescribeKecInventory API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeKecInventoryRequest method.
req, resp := client.DescribeKecInventoryRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeKecInventory

func (*Kec) DescribeKecInventoryWithContext

func (c *Kec) DescribeKecInventoryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeKecInventoryWithContext is the same as DescribeKecInventory with the addition of the ability to pass a context and additional request options.

See DescribeKecInventory for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeLocalVolumeSnapshots

func (c *Kec) DescribeLocalVolumeSnapshots(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLocalVolumeSnapshots API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeLocalVolumeSnapshots for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumeSnapshots

func (*Kec) DescribeLocalVolumeSnapshotsRequest

func (c *Kec) DescribeLocalVolumeSnapshotsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeLocalVolumeSnapshotsRequest generates a "ksc/request.Request" representing the client's request for the DescribeLocalVolumeSnapshots operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeLocalVolumeSnapshots for more information on using the DescribeLocalVolumeSnapshots API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeLocalVolumeSnapshotsRequest method.
req, resp := client.DescribeLocalVolumeSnapshotsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumeSnapshots

func (*Kec) DescribeLocalVolumeSnapshotsWithContext

func (c *Kec) DescribeLocalVolumeSnapshotsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeLocalVolumeSnapshotsWithContext is the same as DescribeLocalVolumeSnapshots with the addition of the ability to pass a context and additional request options.

See DescribeLocalVolumeSnapshots for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeLocalVolumes

func (c *Kec) DescribeLocalVolumes(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeLocalVolumes API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeLocalVolumes for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumes

func (*Kec) DescribeLocalVolumesRequest

func (c *Kec) DescribeLocalVolumesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeLocalVolumesRequest generates a "ksc/request.Request" representing the client's request for the DescribeLocalVolumes operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeLocalVolumes for more information on using the DescribeLocalVolumes API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeLocalVolumesRequest method.
req, resp := client.DescribeLocalVolumesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeLocalVolumes

func (*Kec) DescribeLocalVolumesWithContext

func (c *Kec) DescribeLocalVolumesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeLocalVolumesWithContext is the same as DescribeLocalVolumes with the addition of the ability to pass a context and additional request options.

See DescribeLocalVolumes for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeRegions

func (c *Kec) DescribeRegions(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeRegions API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeRegions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeRegions

func (*Kec) DescribeRegionsRequest

func (c *Kec) DescribeRegionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeRegionsRequest generates a "ksc/request.Request" representing the client's request for the DescribeRegions operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeRegions for more information on using the DescribeRegions API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeRegionsRequest method.
req, resp := client.DescribeRegionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeRegions

func (*Kec) DescribeRegionsWithContext

func (c *Kec) DescribeRegionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeRegionsWithContext is the same as DescribeRegions with the addition of the ability to pass a context and additional request options.

See DescribeRegions for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeScalingActivity

func (c *Kec) DescribeScalingActivity(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingActivity API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeScalingActivity for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingActivity

func (*Kec) DescribeScalingActivityRequest

func (c *Kec) DescribeScalingActivityRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeScalingActivityRequest generates a "ksc/request.Request" representing the client's request for the DescribeScalingActivity operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeScalingActivity for more information on using the DescribeScalingActivity API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeScalingActivityRequest method.
req, resp := client.DescribeScalingActivityRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingActivity

func (*Kec) DescribeScalingActivityWithContext

func (c *Kec) DescribeScalingActivityWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeScalingActivityWithContext is the same as DescribeScalingActivity with the addition of the ability to pass a context and additional request options.

See DescribeScalingActivity for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeScalingConfiguration

func (c *Kec) DescribeScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingConfiguration API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeScalingConfiguration for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingConfiguration

func (*Kec) DescribeScalingConfigurationRequest

func (c *Kec) DescribeScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeScalingConfigurationRequest generates a "ksc/request.Request" representing the client's request for the DescribeScalingConfiguration operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeScalingConfiguration for more information on using the DescribeScalingConfiguration API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeScalingConfigurationRequest method.
req, resp := client.DescribeScalingConfigurationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingConfiguration

func (*Kec) DescribeScalingConfigurationWithContext

func (c *Kec) DescribeScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeScalingConfigurationWithContext is the same as DescribeScalingConfiguration with the addition of the ability to pass a context and additional request options.

See DescribeScalingConfiguration for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeScalingGroup

func (c *Kec) DescribeScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeScalingGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingGroup

func (*Kec) DescribeScalingGroupRequest

func (c *Kec) DescribeScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeScalingGroupRequest generates a "ksc/request.Request" representing the client's request for the DescribeScalingGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeScalingGroup for more information on using the DescribeScalingGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeScalingGroupRequest method.
req, resp := client.DescribeScalingGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingGroup

func (*Kec) DescribeScalingGroupWithContext

func (c *Kec) DescribeScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeScalingGroupWithContext is the same as DescribeScalingGroup with the addition of the ability to pass a context and additional request options.

See DescribeScalingGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeScalingInstance

func (c *Kec) DescribeScalingInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingInstance API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeScalingInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingInstance

func (*Kec) DescribeScalingInstanceRequest

func (c *Kec) DescribeScalingInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeScalingInstanceRequest generates a "ksc/request.Request" representing the client's request for the DescribeScalingInstance operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeScalingInstance for more information on using the DescribeScalingInstance API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeScalingInstanceRequest method.
req, resp := client.DescribeScalingInstanceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingInstance

func (*Kec) DescribeScalingInstanceWithContext

func (c *Kec) DescribeScalingInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeScalingInstanceWithContext is the same as DescribeScalingInstance with the addition of the ability to pass a context and additional request options.

See DescribeScalingInstance for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeScalingNotification

func (c *Kec) DescribeScalingNotification(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingNotification API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeScalingNotification for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingNotification

func (*Kec) DescribeScalingNotificationRequest

func (c *Kec) DescribeScalingNotificationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeScalingNotificationRequest generates a "ksc/request.Request" representing the client's request for the DescribeScalingNotification operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeScalingNotification for more information on using the DescribeScalingNotification API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeScalingNotificationRequest method.
req, resp := client.DescribeScalingNotificationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingNotification

func (*Kec) DescribeScalingNotificationWithContext

func (c *Kec) DescribeScalingNotificationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeScalingNotificationWithContext is the same as DescribeScalingNotification with the addition of the ability to pass a context and additional request options.

See DescribeScalingNotification for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeScalingPolicy

func (c *Kec) DescribeScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScalingPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeScalingPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingPolicy

func (*Kec) DescribeScalingPolicyRequest

func (c *Kec) DescribeScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeScalingPolicyRequest generates a "ksc/request.Request" representing the client's request for the DescribeScalingPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeScalingPolicy for more information on using the DescribeScalingPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeScalingPolicyRequest method.
req, resp := client.DescribeScalingPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScalingPolicy

func (*Kec) DescribeScalingPolicyWithContext

func (c *Kec) DescribeScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeScalingPolicyWithContext is the same as DescribeScalingPolicy with the addition of the ability to pass a context and additional request options.

See DescribeScalingPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DescribeScheduledTask

func (c *Kec) DescribeScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)

DescribeScheduledTask API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DescribeScheduledTask for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScheduledTask

func (*Kec) DescribeScheduledTaskRequest

func (c *Kec) DescribeScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DescribeScheduledTaskRequest generates a "ksc/request.Request" representing the client's request for the DescribeScheduledTask operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DescribeScheduledTask for more information on using the DescribeScheduledTask API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DescribeScheduledTaskRequest method.
req, resp := client.DescribeScheduledTaskRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DescribeScheduledTask

func (*Kec) DescribeScheduledTaskWithContext

func (c *Kec) DescribeScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DescribeScheduledTaskWithContext is the same as DescribeScheduledTask with the addition of the ability to pass a context and additional request options.

See DescribeScheduledTask for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DetachInstance

func (c *Kec) DetachInstance(input *map[string]interface{}) (*map[string]interface{}, error)

DetachInstance API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DetachInstance for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachInstance

func (*Kec) DetachInstanceRequest

func (c *Kec) DetachInstanceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachInstanceRequest generates a "ksc/request.Request" representing the client's request for the DetachInstance operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachInstance for more information on using the DetachInstance API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachInstanceRequest method.
req, resp := client.DetachInstanceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachInstance

func (*Kec) DetachInstanceWithContext

func (c *Kec) DetachInstanceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachInstanceWithContext is the same as DetachInstance with the addition of the ability to pass a context and additional request options.

See DetachInstance for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DetachInstancesIamRole

func (c *Kec) DetachInstancesIamRole(input *map[string]interface{}) (*map[string]interface{}, error)

DetachInstancesIamRole API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DetachInstancesIamRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachInstancesIamRole

func (*Kec) DetachInstancesIamRoleRequest

func (c *Kec) DetachInstancesIamRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachInstancesIamRoleRequest generates a "ksc/request.Request" representing the client's request for the DetachInstancesIamRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachInstancesIamRole for more information on using the DetachInstancesIamRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachInstancesIamRoleRequest method.
req, resp := client.DetachInstancesIamRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachInstancesIamRole

func (*Kec) DetachInstancesIamRoleWithContext

func (c *Kec) DetachInstancesIamRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachInstancesIamRoleWithContext is the same as DetachInstancesIamRole with the addition of the ability to pass a context and additional request options.

See DetachInstancesIamRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DetachKey

func (c *Kec) DetachKey(input *map[string]interface{}) (*map[string]interface{}, error)

DetachKey API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DetachKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachKey

func (*Kec) DetachKeyRequest

func (c *Kec) DetachKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachKeyRequest generates a "ksc/request.Request" representing the client's request for the DetachKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachKey for more information on using the DetachKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachKeyRequest method.
req, resp := client.DetachKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachKey

func (*Kec) DetachKeyWithContext

func (c *Kec) DetachKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachKeyWithContext is the same as DetachKey with the addition of the ability to pass a context and additional request options.

See DetachKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DetachNetworkInterface

func (c *Kec) DetachNetworkInterface(input *map[string]interface{}) (*map[string]interface{}, error)

DetachNetworkInterface API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DetachNetworkInterface for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachNetworkInterface

func (*Kec) DetachNetworkInterfaceRequest

func (c *Kec) DetachNetworkInterfaceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachNetworkInterfaceRequest generates a "ksc/request.Request" representing the client's request for the DetachNetworkInterface operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachNetworkInterface for more information on using the DetachNetworkInterface API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachNetworkInterfaceRequest method.
req, resp := client.DetachNetworkInterfaceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DetachNetworkInterface

func (*Kec) DetachNetworkInterfaceWithContext

func (c *Kec) DetachNetworkInterfaceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachNetworkInterfaceWithContext is the same as DetachNetworkInterface with the addition of the ability to pass a context and additional request options.

See DetachNetworkInterface for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) DisableScalingGroup

func (c *Kec) DisableScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DisableScalingGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation DisableScalingGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DisableScalingGroup

func (*Kec) DisableScalingGroupRequest

func (c *Kec) DisableScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DisableScalingGroupRequest generates a "ksc/request.Request" representing the client's request for the DisableScalingGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DisableScalingGroup for more information on using the DisableScalingGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DisableScalingGroupRequest method.
req, resp := client.DisableScalingGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/DisableScalingGroup

func (*Kec) DisableScalingGroupWithContext

func (c *Kec) DisableScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DisableScalingGroupWithContext is the same as DisableScalingGroup with the addition of the ability to pass a context and additional request options.

See DisableScalingGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) EnableImageCaching

func (c *Kec) EnableImageCaching(input *map[string]interface{}) (*map[string]interface{}, error)

EnableImageCaching API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation EnableImageCaching for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/EnableImageCaching

func (*Kec) EnableImageCachingRequest

func (c *Kec) EnableImageCachingRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableImageCachingRequest generates a "ksc/request.Request" representing the client's request for the EnableImageCaching operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableImageCaching for more information on using the EnableImageCaching API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableImageCachingRequest method.
req, resp := client.EnableImageCachingRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/EnableImageCaching

func (*Kec) EnableImageCachingWithContext

func (c *Kec) EnableImageCachingWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableImageCachingWithContext is the same as EnableImageCaching with the addition of the ability to pass a context and additional request options.

See EnableImageCaching for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) EnableScalingGroup

func (c *Kec) EnableScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)

EnableScalingGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation EnableScalingGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/EnableScalingGroup

func (*Kec) EnableScalingGroupRequest

func (c *Kec) EnableScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableScalingGroupRequest generates a "ksc/request.Request" representing the client's request for the EnableScalingGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableScalingGroup for more information on using the EnableScalingGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableScalingGroupRequest method.
req, resp := client.EnableScalingGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/EnableScalingGroup

func (*Kec) EnableScalingGroupWithContext

func (c *Kec) EnableScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableScalingGroupWithContext is the same as EnableScalingGroup with the addition of the ability to pass a context and additional request options.

See EnableScalingGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ImportImage

func (c *Kec) ImportImage(input *map[string]interface{}) (*map[string]interface{}, error)

ImportImage API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ImportImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ImportImage

func (*Kec) ImportImageRequest

func (c *Kec) ImportImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ImportImageRequest generates a "ksc/request.Request" representing the client's request for the ImportImage operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ImportImage for more information on using the ImportImage API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ImportImageRequest method.
req, resp := client.ImportImageRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ImportImage

func (*Kec) ImportImageWithContext

func (c *Kec) ImportImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ImportImageWithContext is the same as ImportImage with the addition of the ability to pass a context and additional request options.

See ImportImage for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyAutoSnapshotPolicy

func (c *Kec) ModifyAutoSnapshotPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyAutoSnapshotPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyAutoSnapshotPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyAutoSnapshotPolicy

func (*Kec) ModifyAutoSnapshotPolicyRequest

func (c *Kec) ModifyAutoSnapshotPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyAutoSnapshotPolicyRequest generates a "ksc/request.Request" representing the client's request for the ModifyAutoSnapshotPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyAutoSnapshotPolicy for more information on using the ModifyAutoSnapshotPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyAutoSnapshotPolicyRequest method.
req, resp := client.ModifyAutoSnapshotPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyAutoSnapshotPolicy

func (*Kec) ModifyAutoSnapshotPolicyWithContext

func (c *Kec) ModifyAutoSnapshotPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyAutoSnapshotPolicyWithContext is the same as ModifyAutoSnapshotPolicy with the addition of the ability to pass a context and additional request options.

See ModifyAutoSnapshotPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyDataGuardGroups

func (c *Kec) ModifyDataGuardGroups(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyDataGuardGroups API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyDataGuardGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyDataGuardGroups

func (*Kec) ModifyDataGuardGroupsRequest

func (c *Kec) ModifyDataGuardGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyDataGuardGroupsRequest generates a "ksc/request.Request" representing the client's request for the ModifyDataGuardGroups operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyDataGuardGroups for more information on using the ModifyDataGuardGroups API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyDataGuardGroupsRequest method.
req, resp := client.ModifyDataGuardGroupsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyDataGuardGroups

func (*Kec) ModifyDataGuardGroupsWithContext

func (c *Kec) ModifyDataGuardGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyDataGuardGroupsWithContext is the same as ModifyDataGuardGroups with the addition of the ability to pass a context and additional request options.

See ModifyDataGuardGroups for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyImageAttribute

func (c *Kec) ModifyImageAttribute(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyImageAttribute API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyImageAttribute for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageAttribute

func (*Kec) ModifyImageAttributeRequest

func (c *Kec) ModifyImageAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyImageAttributeRequest generates a "ksc/request.Request" representing the client's request for the ModifyImageAttribute operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyImageAttribute for more information on using the ModifyImageAttribute API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyImageAttributeRequest method.
req, resp := client.ModifyImageAttributeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageAttribute

func (*Kec) ModifyImageAttributeWithContext

func (c *Kec) ModifyImageAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyImageAttributeWithContext is the same as ModifyImageAttribute with the addition of the ability to pass a context and additional request options.

See ModifyImageAttribute for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyImageSharePermission

func (c *Kec) ModifyImageSharePermission(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyImageSharePermission API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyImageSharePermission for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageSharePermission

func (*Kec) ModifyImageSharePermissionRequest

func (c *Kec) ModifyImageSharePermissionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyImageSharePermissionRequest generates a "ksc/request.Request" representing the client's request for the ModifyImageSharePermission operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyImageSharePermission for more information on using the ModifyImageSharePermission API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyImageSharePermissionRequest method.
req, resp := client.ModifyImageSharePermissionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyImageSharePermission

func (*Kec) ModifyImageSharePermissionWithContext

func (c *Kec) ModifyImageSharePermissionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyImageSharePermissionWithContext is the same as ModifyImageSharePermission with the addition of the ability to pass a context and additional request options.

See ModifyImageSharePermission for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyInstanceAttribute

func (c *Kec) ModifyInstanceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceAttribute API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyInstanceAttribute for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceAttribute

func (*Kec) ModifyInstanceAttributeRequest

func (c *Kec) ModifyInstanceAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyInstanceAttributeRequest generates a "ksc/request.Request" representing the client's request for the ModifyInstanceAttribute operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyInstanceAttribute for more information on using the ModifyInstanceAttribute API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyInstanceAttributeRequest method.
req, resp := client.ModifyInstanceAttributeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceAttribute

func (*Kec) ModifyInstanceAttributeWithContext

func (c *Kec) ModifyInstanceAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyInstanceAttributeWithContext is the same as ModifyInstanceAttribute with the addition of the ability to pass a context and additional request options.

See ModifyInstanceAttribute for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyInstanceImage

func (c *Kec) ModifyInstanceImage(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceImage API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyInstanceImage for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceImage

func (*Kec) ModifyInstanceImageRequest

func (c *Kec) ModifyInstanceImageRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyInstanceImageRequest generates a "ksc/request.Request" representing the client's request for the ModifyInstanceImage operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyInstanceImage for more information on using the ModifyInstanceImage API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyInstanceImageRequest method.
req, resp := client.ModifyInstanceImageRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceImage

func (*Kec) ModifyInstanceImageWithContext

func (c *Kec) ModifyInstanceImageWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyInstanceImageWithContext is the same as ModifyInstanceImage with the addition of the ability to pass a context and additional request options.

See ModifyInstanceImage for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyInstanceType

func (c *Kec) ModifyInstanceType(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyInstanceType API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyInstanceType for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceType

func (*Kec) ModifyInstanceTypeRequest

func (c *Kec) ModifyInstanceTypeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyInstanceTypeRequest generates a "ksc/request.Request" representing the client's request for the ModifyInstanceType operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyInstanceType for more information on using the ModifyInstanceType API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyInstanceTypeRequest method.
req, resp := client.ModifyInstanceTypeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyInstanceType

func (*Kec) ModifyInstanceTypeWithContext

func (c *Kec) ModifyInstanceTypeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyInstanceTypeWithContext is the same as ModifyInstanceType with the addition of the ability to pass a context and additional request options.

See ModifyInstanceType for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyNetworkInterfaceAttribute

func (c *Kec) ModifyNetworkInterfaceAttribute(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyNetworkInterfaceAttribute API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyNetworkInterfaceAttribute for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyNetworkInterfaceAttribute

func (*Kec) ModifyNetworkInterfaceAttributeRequest

func (c *Kec) ModifyNetworkInterfaceAttributeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyNetworkInterfaceAttributeRequest generates a "ksc/request.Request" representing the client's request for the ModifyNetworkInterfaceAttribute operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyNetworkInterfaceAttribute for more information on using the ModifyNetworkInterfaceAttribute API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyNetworkInterfaceAttributeRequest method.
req, resp := client.ModifyNetworkInterfaceAttributeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyNetworkInterfaceAttribute

func (*Kec) ModifyNetworkInterfaceAttributeWithContext

func (c *Kec) ModifyNetworkInterfaceAttributeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyNetworkInterfaceAttributeWithContext is the same as ModifyNetworkInterfaceAttribute with the addition of the ability to pass a context and additional request options.

See ModifyNetworkInterfaceAttribute for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyScalingConfiguration

func (c *Kec) ModifyScalingConfiguration(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingConfiguration API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyScalingConfiguration for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingConfiguration

func (*Kec) ModifyScalingConfigurationRequest

func (c *Kec) ModifyScalingConfigurationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyScalingConfigurationRequest generates a "ksc/request.Request" representing the client's request for the ModifyScalingConfiguration operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyScalingConfiguration for more information on using the ModifyScalingConfiguration API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyScalingConfigurationRequest method.
req, resp := client.ModifyScalingConfigurationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingConfiguration

func (*Kec) ModifyScalingConfigurationWithContext

func (c *Kec) ModifyScalingConfigurationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyScalingConfigurationWithContext is the same as ModifyScalingConfiguration with the addition of the ability to pass a context and additional request options.

See ModifyScalingConfiguration for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyScalingGroup

func (c *Kec) ModifyScalingGroup(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingGroup API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyScalingGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingGroup

func (*Kec) ModifyScalingGroupRequest

func (c *Kec) ModifyScalingGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyScalingGroupRequest generates a "ksc/request.Request" representing the client's request for the ModifyScalingGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyScalingGroup for more information on using the ModifyScalingGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyScalingGroupRequest method.
req, resp := client.ModifyScalingGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingGroup

func (*Kec) ModifyScalingGroupWithContext

func (c *Kec) ModifyScalingGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyScalingGroupWithContext is the same as ModifyScalingGroup with the addition of the ability to pass a context and additional request options.

See ModifyScalingGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyScalingLoadBalancers

func (c *Kec) ModifyScalingLoadBalancers(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingLoadBalancers API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyScalingLoadBalancers for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingLoadBalancers

func (*Kec) ModifyScalingLoadBalancersRequest

func (c *Kec) ModifyScalingLoadBalancersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyScalingLoadBalancersRequest generates a "ksc/request.Request" representing the client's request for the ModifyScalingLoadBalancers operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyScalingLoadBalancers for more information on using the ModifyScalingLoadBalancers API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyScalingLoadBalancersRequest method.
req, resp := client.ModifyScalingLoadBalancersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingLoadBalancers

func (*Kec) ModifyScalingLoadBalancersWithContext

func (c *Kec) ModifyScalingLoadBalancersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyScalingLoadBalancersWithContext is the same as ModifyScalingLoadBalancers with the addition of the ability to pass a context and additional request options.

See ModifyScalingLoadBalancers for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyScalingNotification

func (c *Kec) ModifyScalingNotification(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingNotification API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyScalingNotification for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingNotification

func (*Kec) ModifyScalingNotificationRequest

func (c *Kec) ModifyScalingNotificationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyScalingNotificationRequest generates a "ksc/request.Request" representing the client's request for the ModifyScalingNotification operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyScalingNotification for more information on using the ModifyScalingNotification API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyScalingNotificationRequest method.
req, resp := client.ModifyScalingNotificationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingNotification

func (*Kec) ModifyScalingNotificationWithContext

func (c *Kec) ModifyScalingNotificationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyScalingNotificationWithContext is the same as ModifyScalingNotification with the addition of the ability to pass a context and additional request options.

See ModifyScalingNotification for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyScalingPolicy

func (c *Kec) ModifyScalingPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScalingPolicy API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyScalingPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingPolicy

func (*Kec) ModifyScalingPolicyRequest

func (c *Kec) ModifyScalingPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyScalingPolicyRequest generates a "ksc/request.Request" representing the client's request for the ModifyScalingPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyScalingPolicy for more information on using the ModifyScalingPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyScalingPolicyRequest method.
req, resp := client.ModifyScalingPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScalingPolicy

func (*Kec) ModifyScalingPolicyWithContext

func (c *Kec) ModifyScalingPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyScalingPolicyWithContext is the same as ModifyScalingPolicy with the addition of the ability to pass a context and additional request options.

See ModifyScalingPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) ModifyScheduledTask

func (c *Kec) ModifyScheduledTask(input *map[string]interface{}) (*map[string]interface{}, error)

ModifyScheduledTask API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation ModifyScheduledTask for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScheduledTask

func (*Kec) ModifyScheduledTaskRequest

func (c *Kec) ModifyScheduledTaskRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ModifyScheduledTaskRequest generates a "ksc/request.Request" representing the client's request for the ModifyScheduledTask operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ModifyScheduledTask for more information on using the ModifyScheduledTask API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ModifyScheduledTaskRequest method.
req, resp := client.ModifyScheduledTaskRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/ModifyScheduledTask

func (*Kec) ModifyScheduledTaskWithContext

func (c *Kec) ModifyScheduledTaskWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ModifyScheduledTaskWithContext is the same as ModifyScheduledTask with the addition of the ability to pass a context and additional request options.

See ModifyScheduledTask for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) RebootInstances

func (c *Kec) RebootInstances(input *map[string]interface{}) (*map[string]interface{}, error)

RebootInstances API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation RebootInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RebootInstances

func (*Kec) RebootInstancesRequest

func (c *Kec) RebootInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RebootInstancesRequest generates a "ksc/request.Request" representing the client's request for the RebootInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RebootInstances for more information on using the RebootInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RebootInstancesRequest method.
req, resp := client.RebootInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RebootInstances

func (*Kec) RebootInstancesWithContext

func (c *Kec) RebootInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RebootInstancesWithContext is the same as RebootInstances with the addition of the ability to pass a context and additional request options.

See RebootInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) RemoveImages

func (c *Kec) RemoveImages(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveImages API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation RemoveImages for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveImages

func (*Kec) RemoveImagesRequest

func (c *Kec) RemoveImagesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RemoveImagesRequest generates a "ksc/request.Request" representing the client's request for the RemoveImages operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RemoveImages for more information on using the RemoveImages API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RemoveImagesRequest method.
req, resp := client.RemoveImagesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveImages

func (*Kec) RemoveImagesWithContext

func (c *Kec) RemoveImagesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RemoveImagesWithContext is the same as RemoveImages with the addition of the ability to pass a context and additional request options.

See RemoveImages for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) RemoveVmFromDataGuard

func (c *Kec) RemoveVmFromDataGuard(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveVmFromDataGuard API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation RemoveVmFromDataGuard for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveVmFromDataGuard

func (*Kec) RemoveVmFromDataGuardRequest

func (c *Kec) RemoveVmFromDataGuardRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RemoveVmFromDataGuardRequest generates a "ksc/request.Request" representing the client's request for the RemoveVmFromDataGuard operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RemoveVmFromDataGuard for more information on using the RemoveVmFromDataGuard API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RemoveVmFromDataGuardRequest method.
req, resp := client.RemoveVmFromDataGuardRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RemoveVmFromDataGuard

func (*Kec) RemoveVmFromDataGuardWithContext

func (c *Kec) RemoveVmFromDataGuardWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RemoveVmFromDataGuardWithContext is the same as RemoveVmFromDataGuard with the addition of the ability to pass a context and additional request options.

See RemoveVmFromDataGuard for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) RollbackLocalVolume

func (c *Kec) RollbackLocalVolume(input *map[string]interface{}) (*map[string]interface{}, error)

RollbackLocalVolume API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation RollbackLocalVolume for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RollbackLocalVolume

func (*Kec) RollbackLocalVolumeRequest

func (c *Kec) RollbackLocalVolumeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RollbackLocalVolumeRequest generates a "ksc/request.Request" representing the client's request for the RollbackLocalVolume operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RollbackLocalVolume for more information on using the RollbackLocalVolume API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RollbackLocalVolumeRequest method.
req, resp := client.RollbackLocalVolumeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RollbackLocalVolume

func (*Kec) RollbackLocalVolumeWithContext

func (c *Kec) RollbackLocalVolumeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RollbackLocalVolumeWithContext is the same as RollbackLocalVolume with the addition of the ability to pass a context and additional request options.

See RollbackLocalVolume for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) RunInstances

func (c *Kec) RunInstances(input *map[string]interface{}) (*map[string]interface{}, error)

RunInstances API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation RunInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RunInstances

func (*Kec) RunInstancesRequest

func (c *Kec) RunInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RunInstancesRequest generates a "ksc/request.Request" representing the client's request for the RunInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RunInstances for more information on using the RunInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RunInstancesRequest method.
req, resp := client.RunInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/RunInstances

func (*Kec) RunInstancesWithContext

func (c *Kec) RunInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RunInstancesWithContext is the same as RunInstances with the addition of the ability to pass a context and additional request options.

See RunInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) SetKvmProtectedDetach

func (c *Kec) SetKvmProtectedDetach(input *map[string]interface{}) (*map[string]interface{}, error)

SetKvmProtectedDetach API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation SetKvmProtectedDetach for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/SetKvmProtectedDetach

func (*Kec) SetKvmProtectedDetachRequest

func (c *Kec) SetKvmProtectedDetachRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetKvmProtectedDetachRequest generates a "ksc/request.Request" representing the client's request for the SetKvmProtectedDetach operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetKvmProtectedDetach for more information on using the SetKvmProtectedDetach API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetKvmProtectedDetachRequest method.
req, resp := client.SetKvmProtectedDetachRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/SetKvmProtectedDetach

func (*Kec) SetKvmProtectedDetachWithContext

func (c *Kec) SetKvmProtectedDetachWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetKvmProtectedDetachWithContext is the same as SetKvmProtectedDetach with the addition of the ability to pass a context and additional request options.

See SetKvmProtectedDetach for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) StartInstances

func (c *Kec) StartInstances(input *map[string]interface{}) (*map[string]interface{}, error)

StartInstances API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation StartInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StartInstances

func (*Kec) StartInstancesRequest

func (c *Kec) StartInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

StartInstancesRequest generates a "ksc/request.Request" representing the client's request for the StartInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See StartInstances for more information on using the StartInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the StartInstancesRequest method.
req, resp := client.StartInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StartInstances

func (*Kec) StartInstancesWithContext

func (c *Kec) StartInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

StartInstancesWithContext is the same as StartInstances with the addition of the ability to pass a context and additional request options.

See StartInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) StopInstances

func (c *Kec) StopInstances(input *map[string]interface{}) (*map[string]interface{}, error)

StopInstances API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation StopInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StopInstances

func (*Kec) StopInstancesRequest

func (c *Kec) StopInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

StopInstancesRequest generates a "ksc/request.Request" representing the client's request for the StopInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See StopInstances for more information on using the StopInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the StopInstancesRequest method.
req, resp := client.StopInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/StopInstances

func (*Kec) StopInstancesWithContext

func (c *Kec) StopInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

StopInstancesWithContext is the same as StopInstances with the addition of the ability to pass a context and additional request options.

See StopInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Kec) TerminateInstances

func (c *Kec) TerminateInstances(input *map[string]interface{}) (*map[string]interface{}, error)

TerminateInstances API operation for kec.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for kec's API operation TerminateInstances for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/TerminateInstances

func (*Kec) TerminateInstancesRequest

func (c *Kec) TerminateInstancesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

TerminateInstancesRequest generates a "ksc/request.Request" representing the client's request for the TerminateInstances operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See TerminateInstances for more information on using the TerminateInstances API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the TerminateInstancesRequest method.
req, resp := client.TerminateInstancesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/kec-2016-03-04/TerminateInstances

func (*Kec) TerminateInstancesWithContext

func (c *Kec) TerminateInstancesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

TerminateInstancesWithContext is the same as TerminateInstances with the addition of the ability to pass a context and additional request options.

See TerminateInstances for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.