func (c *ServiceDiscovery) DeregisterInstance(input *DeregisterInstanceInput) (*DeregisterInstanceOutput, error) {
	req, out := c.DeregisterInstanceRequest(input)
	return out, req.Send()
}
DeregisterInstance API operation for Amazon Route 53 Auto Naming.

Deletes the records and the health check, if any, that Amazon Route 53 created
for the specified instance.

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 AWS API reference guide for Amazon Route 53 Auto Naming's
API operation DeregisterInstance for usage and error information.

Returned Error Codes:
* ErrCodeDuplicateRequest "DuplicateRequest"
The operation is already in progress.

* ErrCodeInvalidInput "InvalidInput"
One or more specified values aren't valid. For example, when you're creating
a namespace, the value of Name might not be a valid DNS name.

* ErrCodeInstanceNotFound "InstanceNotFound"
No instance exists with the specified ID, or the instance was recently registered,
and information about the instance hasn't propagated yet.

* ErrCodeResourceInUse "ResourceInUse"
The specified resource can't be deleted because it contains other resources.
For example, you can't delete a service that contains any instances.

* ErrCodeServiceNotFound "ServiceNotFound"
No service exists with the specified ID.

See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeregisterInstance
package servicediscovery
import (
	"fmt"
	"time"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/private/protocol"
	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
)
const opCreatePrivateDnsNamespace = "CreatePrivateDnsNamespace"
func (c *ServiceDiscovery) CreatePrivateDnsNamespaceRequest(input *CreatePrivateDnsNamespaceInput) (req *request.Request, output *CreatePrivateDnsNamespaceOutput) {
	op := &request.Operation{
		Name:       opCreatePrivateDnsNamespace,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreatePrivateDnsNamespaceInput{}
	}
	output = &CreatePrivateDnsNamespaceOutput{}
	req = c.newRequest(op, input, output)
	return
}
func (c *ServiceDiscovery) CreatePrivateDnsNamespace(input *CreatePrivateDnsNamespaceInput) (*CreatePrivateDnsNamespaceOutput, error) {
	req, out := c.CreatePrivateDnsNamespaceRequest(input)
	return out, req.Send()
}
func (c *ServiceDiscovery) CreatePrivateDnsNamespaceWithContext(ctx aws.Context, input *CreatePrivateDnsNamespaceInput, opts ...request.Option) (*CreatePrivateDnsNamespaceOutput, error) {
	req, out := c.CreatePrivateDnsNamespaceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}
const opCreatePublicDnsNamespace = "CreatePublicDnsNamespace"
func (c *ServiceDiscovery) CreatePublicDnsNamespaceRequest(input *CreatePublicDnsNamespaceInput) (req *request.Request, output *CreatePublicDnsNamespaceOutput) {
	op := &request.Operation{
		Name:       opCreatePublicDnsNamespace,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreatePublicDnsNamespaceInput{}
	}
	output = &CreatePublicDnsNamespaceOutput{}
	req = c.newRequest(op, input, output)
	return
}
func (c *ServiceDiscovery) CreatePublicDnsNamespace(input *CreatePublicDnsNamespaceInput) (*CreatePublicDnsNamespaceOutput, error) {
	req, out := c.CreatePublicDnsNamespaceRequest(input)
	return out, req.Send()
}
func (c *ServiceDiscovery) CreatePublicDnsNamespaceWithContext(ctx aws.Context, input *CreatePublicDnsNamespaceInput, opts ...request.Option) (*CreatePublicDnsNamespaceOutput, error) {
	req, out := c.CreatePublicDnsNamespaceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}
const opCreateService = "CreateService"
func (c *ServiceDiscovery) CreateServiceRequest(input *CreateServiceInput) (req *request.Request, output *CreateServiceOutput) {
	op := &request.Operation{
		Name:       opCreateService,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateServiceInput{}
	}
	output = &CreateServiceOutput{}
	req = c.newRequest(op, input, output)
	return
}
func (c *ServiceDiscovery) CreateService(input *CreateServiceInput) (*CreateServiceOutput, error) {
	req, out := c.CreateServiceRequest(input)
	return out, req.Send()
}
func (c *ServiceDiscovery) CreateServiceWithContext(ctx aws.Context, input *CreateServiceInput, opts ...request.Option) (*CreateServiceOutput, error) {
	req, out := c.CreateServiceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}
const opDeleteNamespace = "DeleteNamespace"
func (c *ServiceDiscovery) DeleteNamespaceRequest(input *DeleteNamespaceInput) (req *request.Request, output *DeleteNamespaceOutput) {
	op := &request.Operation{
		Name:       opDeleteNamespace,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteNamespaceInput{}
	}
	output = &DeleteNamespaceOutput{}
	req = c.newRequest(op, input, output)
	return
}
func (c *ServiceDiscovery) DeleteNamespace(input *DeleteNamespaceInput) (*DeleteNamespaceOutput, error) {
	req, out := c.DeleteNamespaceRequest(input)
	return out, req.Send()
}
func (c *ServiceDiscovery) DeleteNamespaceWithContext(ctx aws.Context, input *DeleteNamespaceInput, opts ...request.Option) (*DeleteNamespaceOutput, error) {
	req, out := c.DeleteNamespaceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}
const opDeleteService = "DeleteService"
func (c *ServiceDiscovery) DeleteServiceRequest(input *DeleteServiceInput) (req *request.Request, output *DeleteServiceOutput) {
	op := &request.Operation{
		Name:       opDeleteService,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteServiceInput{}
	}
	output = &DeleteServiceOutput{}
	req = c.newRequest(op, input, output)
	return
}
func (c *ServiceDiscovery) DeleteService(input *DeleteServiceInput) (*DeleteServiceOutput, error) {
	req, out := c.DeleteServiceRequest(input)
	return out, req.Send()
}
func (c *ServiceDiscovery) DeleteServiceWithContext(ctx aws.Context, input *DeleteServiceInput, opts ...request.Option) (*DeleteServiceOutput, error) {
	req, out := c.DeleteServiceRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}
const opDeregisterInstance = "DeregisterInstance"
func (c *ServiceDiscovery) DeregisterInstanceRequest(input *DeregisterInstanceInput) (req *request.Request, output *DeregisterInstanceOutput) {
	op := &request.Operation{
		Name:       opDeregisterInstance,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeregisterInstanceInput{}
	}
	output = &DeregisterInstanceOutput{}
	req = c.newRequest(op, input, output)
	return
}