diff --git a/providers/route53/route53Provider.go b/providers/route53/route53Provider.go index aa9259942..fcf39729a 100644 --- a/providers/route53/route53Provider.go +++ b/providers/route53/route53Provider.go @@ -3,6 +3,7 @@ package route53 import ( "encoding/json" "fmt" + "sort" "strings" "time" @@ -12,20 +13,34 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/private/waiter" r53 "github.com/aws/aws-sdk-go/service/route53" + r53d "github.com/aws/aws-sdk-go/service/route53domains" "github.com/pkg/errors" ) type route53Provider struct { - client *r53.Route53 - zones map[string]*r53.HostedZone + client *r53.Route53 + registrar *r53d.Route53Domains + zones map[string]*r53.HostedZone } -func newRoute53(m map[string]string, metadata json.RawMessage) (providers.DNSServiceProvider, error) { +func newRoute53Reg(conf map[string]string) (providers.Registrar, error) { + return newRoute53(conf, nil) +} + +func newRoute53Dsp(conf map[string]string, metadata json.RawMessage) (providers.DNSServiceProvider, error) { + return newRoute53(conf, metadata) +} + +func newRoute53(m map[string]string, metadata json.RawMessage) (*route53Provider, error) { keyId, secretKey := m["KeyId"], m["SecretKey"] + // Route53 uses a global endpoint and route53domains + // currently only has a single regional endpoint in us-east-1 + // http://docs.aws.amazon.com/general/latest/gr/rande.html#r53_region config := &aws.Config{ - Region: aws.String("us-west-2"), + Region: aws.String("us-east-1"), } if keyId != "" || secretKey != "" { @@ -33,7 +48,7 @@ func newRoute53(m map[string]string, metadata json.RawMessage) (providers.DNSSer } sess := session.New(config) - api := &route53Provider{client: r53.New(sess)} + api := &route53Provider{client: r53.New(sess), registrar: r53d.New(sess)} err := api.getZones() if err != nil { return nil, err @@ -42,8 +57,10 @@ func newRoute53(m map[string]string, metadata json.RawMessage) (providers.DNSSer } func init() { - providers.RegisterDomainServiceProviderType("ROUTE53", newRoute53, providers.CanUsePTR, providers.CanUseSRV) + providers.RegisterDomainServiceProviderType("ROUTE53", newRoute53Dsp, providers.CanUsePTR, providers.CanUseSRV) + providers.RegisterRegistrarType("ROUTE53", newRoute53Reg) } + func sPtr(s string) *string { return &s } @@ -249,6 +266,69 @@ func (r *route53Provider) GetDomainCorrections(dc *models.DomainConfig) ([]*mode } +func (r *route53Provider) GetRegistrarCorrections(dc *models.DomainConfig) ([]*models.Correction, error) { + corrections := []*models.Correction{} + actualSet, err := r.getRegistrarNameservers(&dc.Name) + if err != nil { + return nil, err + } + sort.Strings(actualSet) + actual := strings.Join(actualSet, ",") + + expectedSet := []string{} + for _, ns := range dc.Nameservers { + expectedSet = append(expectedSet, ns.Name) + } + sort.Strings(expectedSet) + expected := strings.Join(expectedSet, ",") + + if actual != expected { + return []*models.Correction{ + { + Msg: fmt.Sprintf("Update nameservers %s -> %s", actual, expected), + F: func() error { + operationId, err := r.updateRegistrarNameservers(dc.Name, expectedSet) + if err != nil { + return err + } + + return r.waitUntilNameserversUpdate(operationId) + }, + }, + }, nil + } + + return corrections, nil +} + +func (r *route53Provider) getRegistrarNameservers(domainName *string) ([]string, error) { + domainDetail, err := r.registrar.GetDomainDetail(&r53d.GetDomainDetailInput{DomainName: domainName}) + if err != nil { + return nil, err + } + + nameservers := []string{} + for _, ns := range domainDetail.Nameservers { + nameservers = append(nameservers, *ns.Name) + } + + return nameservers, nil +} + +func (r *route53Provider) updateRegistrarNameservers(domainName string, nameservers []string) (*string, error) { + servers := []*r53d.Nameserver{} + for i := range nameservers { + servers = append(servers, &r53d.Nameserver{Name: &nameservers[i]}) + } + + domainUpdate, err := r.registrar.UpdateDomainNameservers(&r53d.UpdateDomainNameserversInput{DomainName: &domainName, Nameservers: servers}) + if err != nil { + return nil, err + } + + return domainUpdate.OperationId, nil +} + func (r *route53Provider) fetchRecordSets(zoneID *string) ([]*r53.ResourceRecordSet, error) { if zoneID == nil || *zoneID == "" { return nil, nil @@ -301,3 +381,31 @@ func (r *route53Provider) EnsureDomainExists(domain string) error { return err } + +func (r *route53Provider) waitUntilNameserversUpdate(operationId *string) error { + fmt.Print("Waiting for registrar update to complete...") + + waiterCfg := waiter.Config{ + Operation: "GetOperationDetail", + Delay: 30, + MaxAttempts: 10, + Acceptors: []waiter.WaitAcceptor{ + { + State: "success", + Matcher: "path", + Argument: "Status", + Expected: "SUCCESSFUL", + }, + }, + } + + w := waiter.Waiter{ + Client: r.registrar, + Input: &r53d.GetOperationDetailInput{ + OperationId: operationId, + }, + Config: waiterCfg, + } + + return w.Wait() +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go new file mode 100644 index 000000000..6efe43d5f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go @@ -0,0 +1,279 @@ +// Package jsonutil provides JSON serialization of AWS requests and responses. +package jsonutil + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "fmt" + "math" + "reflect" + "sort" + "strconv" + "time" + + "github.com/aws/aws-sdk-go/private/protocol" +) + +var timeType = reflect.ValueOf(time.Time{}).Type() +var byteSliceType = reflect.ValueOf([]byte{}).Type() + +// BuildJSON builds a JSON string for a given object v. +func BuildJSON(v interface{}) ([]byte, error) { + var buf bytes.Buffer + + err := buildAny(reflect.ValueOf(v), &buf, "") + return buf.Bytes(), err +} + +func buildAny(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error { + origVal := value + value = reflect.Indirect(value) + if !value.IsValid() { + return nil + } + + vtype := value.Type() + + t := tag.Get("type") + if t == "" { + switch vtype.Kind() { + case reflect.Struct: + // also it can't be a time object + if value.Type() != timeType { + t = "structure" + } + case reflect.Slice: + // also it can't be a byte slice + if _, ok := value.Interface().([]byte); !ok { + t = "list" + } + case reflect.Map: + t = "map" + } + } + + switch t { + case "structure": + if field, ok := vtype.FieldByName("_"); ok { + tag = field.Tag + } + return buildStruct(value, buf, tag) + case "list": + return buildList(value, buf, tag) + case "map": + return buildMap(value, buf, tag) + default: + return buildScalar(origVal, buf, tag) + } +} + +func buildStruct(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error { + if !value.IsValid() { + return nil + } + + // unwrap payloads + if payload := tag.Get("payload"); payload != "" { + field, _ := value.Type().FieldByName(payload) + tag = field.Tag + value = elemOf(value.FieldByName(payload)) + + if !value.IsValid() { + return nil + } + } + + buf.WriteByte('{') + + t := value.Type() + first := true + for i := 0; i < t.NumField(); i++ { + member := value.Field(i) + + // This allocates the most memory. + // Additionally, we cannot skip nil fields due to + // idempotency auto filling. + field := t.Field(i) + + if field.PkgPath != "" { + continue // ignore unexported fields + } + if field.Tag.Get("json") == "-" { + continue + } + if field.Tag.Get("location") != "" { + continue // ignore non-body elements + } + if field.Tag.Get("ignore") != "" { + continue + } + + if protocol.CanSetIdempotencyToken(member, field) { + token := protocol.GetIdempotencyToken() + member = reflect.ValueOf(&token) + } + + if (member.Kind() == reflect.Ptr || member.Kind() == reflect.Slice || member.Kind() == reflect.Map) && member.IsNil() { + continue // ignore unset fields + } + + if first { + first = false + } else { + buf.WriteByte(',') + } + + // figure out what this field is called + name := field.Name + if locName := field.Tag.Get("locationName"); locName != "" { + name = locName + } + + writeString(name, buf) + buf.WriteString(`:`) + + err := buildAny(member, buf, field.Tag) + if err != nil { + return err + } + + } + + buf.WriteString("}") + + return nil +} + +func buildList(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error { + buf.WriteString("[") + + for i := 0; i < value.Len(); i++ { + buildAny(value.Index(i), buf, "") + + if i < value.Len()-1 { + buf.WriteString(",") + } + } + + buf.WriteString("]") + + return nil +} + +type sortedValues []reflect.Value + +func (sv sortedValues) Len() int { return len(sv) } +func (sv sortedValues) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] } +func (sv sortedValues) Less(i, j int) bool { return sv[i].String() < sv[j].String() } + +func buildMap(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error { + buf.WriteString("{") + + sv := sortedValues(value.MapKeys()) + sort.Sort(sv) + + for i, k := range sv { + if i > 0 { + buf.WriteByte(',') + } + + writeString(k.String(), buf) + buf.WriteString(`:`) + + buildAny(value.MapIndex(k), buf, "") + } + + buf.WriteString("}") + + return nil +} + +func buildScalar(v reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error { + // prevents allocation on the heap. + scratch := [64]byte{} + switch value := reflect.Indirect(v); value.Kind() { + case reflect.String: + writeString(value.String(), buf) + case reflect.Bool: + if value.Bool() { + buf.WriteString("true") + } else { + buf.WriteString("false") + } + case reflect.Int64: + buf.Write(strconv.AppendInt(scratch[:0], value.Int(), 10)) + case reflect.Float64: + f := value.Float() + if math.IsInf(f, 0) || math.IsNaN(f) { + return &json.UnsupportedValueError{Value: v, Str: strconv.FormatFloat(f, 'f', -1, 64)} + } + buf.Write(strconv.AppendFloat(scratch[:0], f, 'f', -1, 64)) + default: + switch value.Type() { + case timeType: + converted := v.Interface().(*time.Time) + + buf.Write(strconv.AppendInt(scratch[:0], converted.UTC().Unix(), 10)) + case byteSliceType: + if !value.IsNil() { + converted := value.Interface().([]byte) + buf.WriteByte('"') + if len(converted) < 1024 { + // for small buffers, using Encode directly is much faster. + dst := make([]byte, base64.StdEncoding.EncodedLen(len(converted))) + base64.StdEncoding.Encode(dst, converted) + buf.Write(dst) + } else { + // for large buffers, avoid unnecessary extra temporary + // buffer space. + enc := base64.NewEncoder(base64.StdEncoding, buf) + enc.Write(converted) + enc.Close() + } + buf.WriteByte('"') + } + default: + return fmt.Errorf("unsupported JSON value %v (%s)", value.Interface(), value.Type()) + } + } + return nil +} + +var hex = "0123456789abcdef" + +func writeString(s string, buf *bytes.Buffer) { + buf.WriteByte('"') + for i := 0; i < len(s); i++ { + if s[i] == '"' { + buf.WriteString(`\"`) + } else if s[i] == '\\' { + buf.WriteString(`\\`) + } else if s[i] == '\b' { + buf.WriteString(`\b`) + } else if s[i] == '\f' { + buf.WriteString(`\f`) + } else if s[i] == '\r' { + buf.WriteString(`\r`) + } else if s[i] == '\t' { + buf.WriteString(`\t`) + } else if s[i] == '\n' { + buf.WriteString(`\n`) + } else if s[i] < 32 { + buf.WriteString("\\u00") + buf.WriteByte(hex[s[i]>>4]) + buf.WriteByte(hex[s[i]&0xF]) + } else { + buf.WriteByte(s[i]) + } + } + buf.WriteByte('"') +} + +// Returns the reflection element of a value, if it is a pointer. +func elemOf(value reflect.Value) reflect.Value { + for value.Kind() == reflect.Ptr { + value = value.Elem() + } + return value +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go new file mode 100644 index 000000000..fea535613 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go @@ -0,0 +1,213 @@ +package jsonutil + +import ( + "encoding/base64" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "reflect" + "time" +) + +// UnmarshalJSON reads a stream and unmarshals the results in object v. +func UnmarshalJSON(v interface{}, stream io.Reader) error { + var out interface{} + + b, err := ioutil.ReadAll(stream) + if err != nil { + return err + } + + if len(b) == 0 { + return nil + } + + if err := json.Unmarshal(b, &out); err != nil { + return err + } + + return unmarshalAny(reflect.ValueOf(v), out, "") +} + +func unmarshalAny(value reflect.Value, data interface{}, tag reflect.StructTag) error { + vtype := value.Type() + if vtype.Kind() == reflect.Ptr { + vtype = vtype.Elem() // check kind of actual element type + } + + t := tag.Get("type") + if t == "" { + switch vtype.Kind() { + case reflect.Struct: + // also it can't be a time object + if _, ok := value.Interface().(*time.Time); !ok { + t = "structure" + } + case reflect.Slice: + // also it can't be a byte slice + if _, ok := value.Interface().([]byte); !ok { + t = "list" + } + case reflect.Map: + t = "map" + } + } + + switch t { + case "structure": + if field, ok := vtype.FieldByName("_"); ok { + tag = field.Tag + } + return unmarshalStruct(value, data, tag) + case "list": + return unmarshalList(value, data, tag) + case "map": + return unmarshalMap(value, data, tag) + default: + return unmarshalScalar(value, data, tag) + } +} + +func unmarshalStruct(value reflect.Value, data interface{}, tag reflect.StructTag) error { + if data == nil { + return nil + } + mapData, ok := data.(map[string]interface{}) + if !ok { + return fmt.Errorf("JSON value is not a structure (%#v)", data) + } + + t := value.Type() + if value.Kind() == reflect.Ptr { + if value.IsNil() { // create the structure if it's nil + s := reflect.New(value.Type().Elem()) + value.Set(s) + value = s + } + + value = value.Elem() + t = t.Elem() + } + + // unwrap any payloads + if payload := tag.Get("payload"); payload != "" { + field, _ := t.FieldByName(payload) + return unmarshalAny(value.FieldByName(payload), data, field.Tag) + } + + for i := 0; i < t.NumField(); i++ { + field := t.Field(i) + if field.PkgPath != "" { + continue // ignore unexported fields + } + + // figure out what this field is called + name := field.Name + if locName := field.Tag.Get("locationName"); locName != "" { + name = locName + } + + member := value.FieldByIndex(field.Index) + err := unmarshalAny(member, mapData[name], field.Tag) + if err != nil { + return err + } + } + return nil +} + +func unmarshalList(value reflect.Value, data interface{}, tag reflect.StructTag) error { + if data == nil { + return nil + } + listData, ok := data.([]interface{}) + if !ok { + return fmt.Errorf("JSON value is not a list (%#v)", data) + } + + if value.IsNil() { + l := len(listData) + value.Set(reflect.MakeSlice(value.Type(), l, l)) + } + + for i, c := range listData { + err := unmarshalAny(value.Index(i), c, "") + if err != nil { + return err + } + } + + return nil +} + +func unmarshalMap(value reflect.Value, data interface{}, tag reflect.StructTag) error { + if data == nil { + return nil + } + mapData, ok := data.(map[string]interface{}) + if !ok { + return fmt.Errorf("JSON value is not a map (%#v)", data) + } + + if value.IsNil() { + value.Set(reflect.MakeMap(value.Type())) + } + + for k, v := range mapData { + kvalue := reflect.ValueOf(k) + vvalue := reflect.New(value.Type().Elem()).Elem() + + unmarshalAny(vvalue, v, "") + value.SetMapIndex(kvalue, vvalue) + } + + return nil +} + +func unmarshalScalar(value reflect.Value, data interface{}, tag reflect.StructTag) error { + errf := func() error { + return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type()) + } + + switch d := data.(type) { + case nil: + return nil // nothing to do here + case string: + switch value.Interface().(type) { + case *string: + value.Set(reflect.ValueOf(&d)) + case []byte: + b, err := base64.StdEncoding.DecodeString(d) + if err != nil { + return err + } + value.Set(reflect.ValueOf(b)) + default: + return errf() + } + case float64: + switch value.Interface().(type) { + case *int64: + di := int64(d) + value.Set(reflect.ValueOf(&di)) + case *float64: + value.Set(reflect.ValueOf(&d)) + case *time.Time: + t := time.Unix(int64(d), 0).UTC() + value.Set(reflect.ValueOf(&t)) + default: + return errf() + } + case bool: + switch value.Interface().(type) { + case *bool: + value.Set(reflect.ValueOf(&d)) + default: + return errf() + } + default: + return fmt.Errorf("unsupported JSON value (%v)", data) + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/jsonrpc.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/jsonrpc.go new file mode 100644 index 000000000..56af4dc44 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/jsonrpc.go @@ -0,0 +1,111 @@ +// Package jsonrpc provides JSON RPC utilities for serialization of AWS +// requests and responses. +package jsonrpc + +//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/json.json build_test.go +//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/json.json unmarshal_test.go + +import ( + "encoding/json" + "io/ioutil" + "strings" + + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" + "github.com/aws/aws-sdk-go/private/protocol/rest" +) + +var emptyJSON = []byte("{}") + +// BuildHandler is a named request handler for building jsonrpc protocol requests +var BuildHandler = request.NamedHandler{Name: "awssdk.jsonrpc.Build", Fn: Build} + +// UnmarshalHandler is a named request handler for unmarshaling jsonrpc protocol requests +var UnmarshalHandler = request.NamedHandler{Name: "awssdk.jsonrpc.Unmarshal", Fn: Unmarshal} + +// UnmarshalMetaHandler is a named request handler for unmarshaling jsonrpc protocol request metadata +var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.jsonrpc.UnmarshalMeta", Fn: UnmarshalMeta} + +// UnmarshalErrorHandler is a named request handler for unmarshaling jsonrpc protocol request errors +var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.jsonrpc.UnmarshalError", Fn: UnmarshalError} + +// Build builds a JSON payload for a JSON RPC request. +func Build(req *request.Request) { + var buf []byte + var err error + if req.ParamsFilled() { + buf, err = jsonutil.BuildJSON(req.Params) + if err != nil { + req.Error = awserr.New("SerializationError", "failed encoding JSON RPC request", err) + return + } + } else { + buf = emptyJSON + } + + if req.ClientInfo.TargetPrefix != "" || string(buf) != "{}" { + req.SetBufferBody(buf) + } + + if req.ClientInfo.TargetPrefix != "" { + target := req.ClientInfo.TargetPrefix + "." + req.Operation.Name + req.HTTPRequest.Header.Add("X-Amz-Target", target) + } + if req.ClientInfo.JSONVersion != "" { + jsonVersion := req.ClientInfo.JSONVersion + req.HTTPRequest.Header.Add("Content-Type", "application/x-amz-json-"+jsonVersion) + } +} + +// Unmarshal unmarshals a response for a JSON RPC service. +func Unmarshal(req *request.Request) { + defer req.HTTPResponse.Body.Close() + if req.DataFilled() { + err := jsonutil.UnmarshalJSON(req.Data, req.HTTPResponse.Body) + if err != nil { + req.Error = awserr.New("SerializationError", "failed decoding JSON RPC response", err) + } + } + return +} + +// UnmarshalMeta unmarshals headers from a response for a JSON RPC service. +func UnmarshalMeta(req *request.Request) { + rest.UnmarshalMeta(req) +} + +// UnmarshalError unmarshals an error response for a JSON RPC service. +func UnmarshalError(req *request.Request) { + defer req.HTTPResponse.Body.Close() + bodyBytes, err := ioutil.ReadAll(req.HTTPResponse.Body) + if err != nil { + req.Error = awserr.New("SerializationError", "failed reading JSON RPC error response", err) + return + } + if len(bodyBytes) == 0 { + req.Error = awserr.NewRequestFailure( + awserr.New("SerializationError", req.HTTPResponse.Status, nil), + req.HTTPResponse.StatusCode, + "", + ) + return + } + var jsonErr jsonErrorResponse + if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil { + req.Error = awserr.New("SerializationError", "failed decoding JSON RPC error response", err) + return + } + + codes := strings.SplitN(jsonErr.Code, "#", 2) + req.Error = awserr.NewRequestFailure( + awserr.New(codes[len(codes)-1], jsonErr.Message, nil), + req.HTTPResponse.StatusCode, + req.RequestID, + ) +} + +type jsonErrorResponse struct { + Code string `json:"__type"` + Message string `json:"message"` +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/route53domains/api.go b/vendor/github.com/aws/aws-sdk-go/service/route53domains/api.go new file mode 100644 index 000000000..1f90d070d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/route53domains/api.go @@ -0,0 +1,4472 @@ +// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. + +// Package route53domains provides a client for Amazon Route 53 Domains. +package route53domains + +import ( + "fmt" + "time" + + "github.com/aws/aws-sdk-go/aws/awsutil" + "github.com/aws/aws-sdk-go/aws/request" +) + +const opCheckDomainAvailability = "CheckDomainAvailability" + +// CheckDomainAvailabilityRequest generates a "aws/request.Request" representing the +// client's request for the CheckDomainAvailability operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the CheckDomainAvailability method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the CheckDomainAvailabilityRequest method. +// req, resp := client.CheckDomainAvailabilityRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) CheckDomainAvailabilityRequest(input *CheckDomainAvailabilityInput) (req *request.Request, output *CheckDomainAvailabilityOutput) { + op := &request.Operation{ + Name: opCheckDomainAvailability, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CheckDomainAvailabilityInput{} + } + + req = c.newRequest(op, input, output) + output = &CheckDomainAvailabilityOutput{} + req.Data = output + return +} + +// This operation checks the availability of one domain name. Note that if the +// availability status of a domain is pending, you must submit another request +// to determine the availability of the domain name. +func (c *Route53Domains) CheckDomainAvailability(input *CheckDomainAvailabilityInput) (*CheckDomainAvailabilityOutput, error) { + req, out := c.CheckDomainAvailabilityRequest(input) + err := req.Send() + return out, err +} + +const opDeleteTagsForDomain = "DeleteTagsForDomain" + +// DeleteTagsForDomainRequest generates a "aws/request.Request" representing the +// client's request for the DeleteTagsForDomain operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the DeleteTagsForDomain method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the DeleteTagsForDomainRequest method. +// req, resp := client.DeleteTagsForDomainRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) DeleteTagsForDomainRequest(input *DeleteTagsForDomainInput) (req *request.Request, output *DeleteTagsForDomainOutput) { + op := &request.Operation{ + Name: opDeleteTagsForDomain, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DeleteTagsForDomainInput{} + } + + req = c.newRequest(op, input, output) + output = &DeleteTagsForDomainOutput{} + req.Data = output + return +} + +// This operation deletes the specified tags for a domain. +// +// All tag operations are eventually consistent; subsequent operations may +// not immediately represent all issued operations. +func (c *Route53Domains) DeleteTagsForDomain(input *DeleteTagsForDomainInput) (*DeleteTagsForDomainOutput, error) { + req, out := c.DeleteTagsForDomainRequest(input) + err := req.Send() + return out, err +} + +const opDisableDomainAutoRenew = "DisableDomainAutoRenew" + +// DisableDomainAutoRenewRequest generates a "aws/request.Request" representing the +// client's request for the DisableDomainAutoRenew operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the DisableDomainAutoRenew method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the DisableDomainAutoRenewRequest method. +// req, resp := client.DisableDomainAutoRenewRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) DisableDomainAutoRenewRequest(input *DisableDomainAutoRenewInput) (req *request.Request, output *DisableDomainAutoRenewOutput) { + op := &request.Operation{ + Name: opDisableDomainAutoRenew, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DisableDomainAutoRenewInput{} + } + + req = c.newRequest(op, input, output) + output = &DisableDomainAutoRenewOutput{} + req.Data = output + return +} + +// This operation disables automatic renewal of domain registration for the +// specified domain. +func (c *Route53Domains) DisableDomainAutoRenew(input *DisableDomainAutoRenewInput) (*DisableDomainAutoRenewOutput, error) { + req, out := c.DisableDomainAutoRenewRequest(input) + err := req.Send() + return out, err +} + +const opDisableDomainTransferLock = "DisableDomainTransferLock" + +// DisableDomainTransferLockRequest generates a "aws/request.Request" representing the +// client's request for the DisableDomainTransferLock operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the DisableDomainTransferLock method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the DisableDomainTransferLockRequest method. +// req, resp := client.DisableDomainTransferLockRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) DisableDomainTransferLockRequest(input *DisableDomainTransferLockInput) (req *request.Request, output *DisableDomainTransferLockOutput) { + op := &request.Operation{ + Name: opDisableDomainTransferLock, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DisableDomainTransferLockInput{} + } + + req = c.newRequest(op, input, output) + output = &DisableDomainTransferLockOutput{} + req.Data = output + return +} + +// This operation removes the transfer lock on the domain (specifically the +// clientTransferProhibited status) to allow domain transfers. We recommend +// you refrain from performing this action unless you intend to transfer the +// domain to a different registrar. Successful submission returns an operation +// ID that you can use to track the progress and completion of the action. If +// the request is not completed successfully, the domain registrant will be +// notified by email. +func (c *Route53Domains) DisableDomainTransferLock(input *DisableDomainTransferLockInput) (*DisableDomainTransferLockOutput, error) { + req, out := c.DisableDomainTransferLockRequest(input) + err := req.Send() + return out, err +} + +const opEnableDomainAutoRenew = "EnableDomainAutoRenew" + +// EnableDomainAutoRenewRequest generates a "aws/request.Request" representing the +// client's request for the EnableDomainAutoRenew operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the EnableDomainAutoRenew method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the EnableDomainAutoRenewRequest method. +// req, resp := client.EnableDomainAutoRenewRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) EnableDomainAutoRenewRequest(input *EnableDomainAutoRenewInput) (req *request.Request, output *EnableDomainAutoRenewOutput) { + op := &request.Operation{ + Name: opEnableDomainAutoRenew, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &EnableDomainAutoRenewInput{} + } + + req = c.newRequest(op, input, output) + output = &EnableDomainAutoRenewOutput{} + req.Data = output + return +} + +// This operation configures Amazon Route 53 to automatically renew the specified +// domain before the domain registration expires. The cost of renewing your +// domain registration is billed to your AWS account. +// +// The period during which you can renew a domain name varies by TLD. For a +// list of TLDs and their renewal policies, see "Renewal, restoration, and deletion +// times" (http://wiki.gandi.net/en/domains/renew#renewal_restoration_and_deletion_times) +// on the website for our registrar partner, Gandi. Route 53 requires that you +// renew before the end of the renewal period that is listed on the Gandi website +// so we can complete processing before the deadline. +func (c *Route53Domains) EnableDomainAutoRenew(input *EnableDomainAutoRenewInput) (*EnableDomainAutoRenewOutput, error) { + req, out := c.EnableDomainAutoRenewRequest(input) + err := req.Send() + return out, err +} + +const opEnableDomainTransferLock = "EnableDomainTransferLock" + +// EnableDomainTransferLockRequest generates a "aws/request.Request" representing the +// client's request for the EnableDomainTransferLock operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the EnableDomainTransferLock method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the EnableDomainTransferLockRequest method. +// req, resp := client.EnableDomainTransferLockRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) EnableDomainTransferLockRequest(input *EnableDomainTransferLockInput) (req *request.Request, output *EnableDomainTransferLockOutput) { + op := &request.Operation{ + Name: opEnableDomainTransferLock, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &EnableDomainTransferLockInput{} + } + + req = c.newRequest(op, input, output) + output = &EnableDomainTransferLockOutput{} + req.Data = output + return +} + +// This operation sets the transfer lock on the domain (specifically the clientTransferProhibited +// status) to prevent domain transfers. Successful submission returns an operation +// ID that you can use to track the progress and completion of the action. If +// the request is not completed successfully, the domain registrant will be +// notified by email. +func (c *Route53Domains) EnableDomainTransferLock(input *EnableDomainTransferLockInput) (*EnableDomainTransferLockOutput, error) { + req, out := c.EnableDomainTransferLockRequest(input) + err := req.Send() + return out, err +} + +const opGetContactReachabilityStatus = "GetContactReachabilityStatus" + +// GetContactReachabilityStatusRequest generates a "aws/request.Request" representing the +// client's request for the GetContactReachabilityStatus operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the GetContactReachabilityStatus method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the GetContactReachabilityStatusRequest method. +// req, resp := client.GetContactReachabilityStatusRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) GetContactReachabilityStatusRequest(input *GetContactReachabilityStatusInput) (req *request.Request, output *GetContactReachabilityStatusOutput) { + op := &request.Operation{ + Name: opGetContactReachabilityStatus, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &GetContactReachabilityStatusInput{} + } + + req = c.newRequest(op, input, output) + output = &GetContactReachabilityStatusOutput{} + req.Data = output + return +} + +// For operations that require confirmation that the email address for the registrant +// contact is valid, such as registering a new domain, this operation returns +// information about whether the registrant contact has responded. +// +// If you want us to resend the email, use the ResendContactReachabilityEmail +// operation. +func (c *Route53Domains) GetContactReachabilityStatus(input *GetContactReachabilityStatusInput) (*GetContactReachabilityStatusOutput, error) { + req, out := c.GetContactReachabilityStatusRequest(input) + err := req.Send() + return out, err +} + +const opGetDomainDetail = "GetDomainDetail" + +// GetDomainDetailRequest generates a "aws/request.Request" representing the +// client's request for the GetDomainDetail operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the GetDomainDetail method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the GetDomainDetailRequest method. +// req, resp := client.GetDomainDetailRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) GetDomainDetailRequest(input *GetDomainDetailInput) (req *request.Request, output *GetDomainDetailOutput) { + op := &request.Operation{ + Name: opGetDomainDetail, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &GetDomainDetailInput{} + } + + req = c.newRequest(op, input, output) + output = &GetDomainDetailOutput{} + req.Data = output + return +} + +// This operation returns detailed information about the domain. The domain's +// contact information is also returned as part of the output. +func (c *Route53Domains) GetDomainDetail(input *GetDomainDetailInput) (*GetDomainDetailOutput, error) { + req, out := c.GetDomainDetailRequest(input) + err := req.Send() + return out, err +} + +const opGetDomainSuggestions = "GetDomainSuggestions" + +// GetDomainSuggestionsRequest generates a "aws/request.Request" representing the +// client's request for the GetDomainSuggestions operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the GetDomainSuggestions method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the GetDomainSuggestionsRequest method. +// req, resp := client.GetDomainSuggestionsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) GetDomainSuggestionsRequest(input *GetDomainSuggestionsInput) (req *request.Request, output *GetDomainSuggestionsOutput) { + op := &request.Operation{ + Name: opGetDomainSuggestions, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &GetDomainSuggestionsInput{} + } + + req = c.newRequest(op, input, output) + output = &GetDomainSuggestionsOutput{} + req.Data = output + return +} + +// The GetDomainSuggestions operation returns a list of suggested domain names +// given a string, which can either be a domain name or simply a word or phrase +// (without spaces). +// +// Parameters: DomainName (string): The basis for your domain suggestion search, +// a string with (or without) top-level domain specified. SuggestionCount (int): +// The number of domain suggestions to be returned, maximum 50, minimum 1. OnlyAvailable +// (bool): If true, availability check will be performed on suggestion results, +// and only available domains will be returned. If false, suggestions will be +// returned without checking whether the domain is actually available, and caller +// will have to call checkDomainAvailability for each suggestion to determine +// availability for registration. +func (c *Route53Domains) GetDomainSuggestions(input *GetDomainSuggestionsInput) (*GetDomainSuggestionsOutput, error) { + req, out := c.GetDomainSuggestionsRequest(input) + err := req.Send() + return out, err +} + +const opGetOperationDetail = "GetOperationDetail" + +// GetOperationDetailRequest generates a "aws/request.Request" representing the +// client's request for the GetOperationDetail operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the GetOperationDetail method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the GetOperationDetailRequest method. +// req, resp := client.GetOperationDetailRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) GetOperationDetailRequest(input *GetOperationDetailInput) (req *request.Request, output *GetOperationDetailOutput) { + op := &request.Operation{ + Name: opGetOperationDetail, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &GetOperationDetailInput{} + } + + req = c.newRequest(op, input, output) + output = &GetOperationDetailOutput{} + req.Data = output + return +} + +// This operation returns the current status of an operation that is not completed. +func (c *Route53Domains) GetOperationDetail(input *GetOperationDetailInput) (*GetOperationDetailOutput, error) { + req, out := c.GetOperationDetailRequest(input) + err := req.Send() + return out, err +} + +const opListDomains = "ListDomains" + +// ListDomainsRequest generates a "aws/request.Request" representing the +// client's request for the ListDomains operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the ListDomains method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the ListDomainsRequest method. +// req, resp := client.ListDomainsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) ListDomainsRequest(input *ListDomainsInput) (req *request.Request, output *ListDomainsOutput) { + op := &request.Operation{ + Name: opListDomains, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"Marker"}, + OutputTokens: []string{"NextPageMarker"}, + LimitToken: "MaxItems", + TruncationToken: "", + }, + } + + if input == nil { + input = &ListDomainsInput{} + } + + req = c.newRequest(op, input, output) + output = &ListDomainsOutput{} + req.Data = output + return +} + +// This operation returns all the domain names registered with Amazon Route +// 53 for the current AWS account. +func (c *Route53Domains) ListDomains(input *ListDomainsInput) (*ListDomainsOutput, error) { + req, out := c.ListDomainsRequest(input) + err := req.Send() + return out, err +} + +// ListDomainsPages iterates over the pages of a ListDomains operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See ListDomains method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a ListDomains operation. +// pageNum := 0 +// err := client.ListDomainsPages(params, +// func(page *ListDomainsOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Route53Domains) ListDomainsPages(input *ListDomainsInput, fn func(p *ListDomainsOutput, lastPage bool) (shouldContinue bool)) error { + page, _ := c.ListDomainsRequest(input) + page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) + return page.EachPage(func(p interface{}, lastPage bool) bool { + return fn(p.(*ListDomainsOutput), lastPage) + }) +} + +const opListOperations = "ListOperations" + +// ListOperationsRequest generates a "aws/request.Request" representing the +// client's request for the ListOperations operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the ListOperations method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the ListOperationsRequest method. +// req, resp := client.ListOperationsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) ListOperationsRequest(input *ListOperationsInput) (req *request.Request, output *ListOperationsOutput) { + op := &request.Operation{ + Name: opListOperations, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"Marker"}, + OutputTokens: []string{"NextPageMarker"}, + LimitToken: "MaxItems", + TruncationToken: "", + }, + } + + if input == nil { + input = &ListOperationsInput{} + } + + req = c.newRequest(op, input, output) + output = &ListOperationsOutput{} + req.Data = output + return +} + +// This operation returns the operation IDs of operations that are not yet complete. +func (c *Route53Domains) ListOperations(input *ListOperationsInput) (*ListOperationsOutput, error) { + req, out := c.ListOperationsRequest(input) + err := req.Send() + return out, err +} + +// ListOperationsPages iterates over the pages of a ListOperations operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See ListOperations method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a ListOperations operation. +// pageNum := 0 +// err := client.ListOperationsPages(params, +// func(page *ListOperationsOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Route53Domains) ListOperationsPages(input *ListOperationsInput, fn func(p *ListOperationsOutput, lastPage bool) (shouldContinue bool)) error { + page, _ := c.ListOperationsRequest(input) + page.Handlers.Build.PushBack(request.MakeAddToUserAgentFreeFormHandler("Paginator")) + return page.EachPage(func(p interface{}, lastPage bool) bool { + return fn(p.(*ListOperationsOutput), lastPage) + }) +} + +const opListTagsForDomain = "ListTagsForDomain" + +// ListTagsForDomainRequest generates a "aws/request.Request" representing the +// client's request for the ListTagsForDomain operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the ListTagsForDomain method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the ListTagsForDomainRequest method. +// req, resp := client.ListTagsForDomainRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) ListTagsForDomainRequest(input *ListTagsForDomainInput) (req *request.Request, output *ListTagsForDomainOutput) { + op := &request.Operation{ + Name: opListTagsForDomain, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ListTagsForDomainInput{} + } + + req = c.newRequest(op, input, output) + output = &ListTagsForDomainOutput{} + req.Data = output + return +} + +// This operation returns all of the tags that are associated with the specified +// domain. +// +// All tag operations are eventually consistent; subsequent operations may +// not immediately represent all issued operations. +func (c *Route53Domains) ListTagsForDomain(input *ListTagsForDomainInput) (*ListTagsForDomainOutput, error) { + req, out := c.ListTagsForDomainRequest(input) + err := req.Send() + return out, err +} + +const opRegisterDomain = "RegisterDomain" + +// RegisterDomainRequest generates a "aws/request.Request" representing the +// client's request for the RegisterDomain operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the RegisterDomain method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the RegisterDomainRequest method. +// req, resp := client.RegisterDomainRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) RegisterDomainRequest(input *RegisterDomainInput) (req *request.Request, output *RegisterDomainOutput) { + op := &request.Operation{ + Name: opRegisterDomain, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RegisterDomainInput{} + } + + req = c.newRequest(op, input, output) + output = &RegisterDomainOutput{} + req.Data = output + return +} + +// This operation registers a domain. Domains are registered by the AWS registrar +// partner, Gandi. For some top-level domains (TLDs), this operation requires +// extra parameters. +// +// When you register a domain, Amazon Route 53 does the following: +// +// Creates a Amazon Route 53 hosted zone that has the same name as the domain. +// Amazon Route 53 assigns four name servers to your hosted zone and automatically +// updates your domain registration with the names of these name servers. Enables +// autorenew, so your domain registration will renew automatically each year. +// We'll notify you in advance of the renewal date so you can choose whether +// to renew the registration. Optionally enables privacy protection, so WHOIS +// queries return contact information for our registrar partner, Gandi, instead +// of the information you entered for registrant, admin, and tech contacts. +// If registration is successful, returns an operation ID that you can use to +// track the progress and completion of the action. If the request is not completed +// successfully, the domain registrant is notified by email. Charges your AWS +// account an amount based on the top-level domain. For more information, see +// Amazon Route 53 Pricing (http://aws.amazon.com/route53/pricing/). +func (c *Route53Domains) RegisterDomain(input *RegisterDomainInput) (*RegisterDomainOutput, error) { + req, out := c.RegisterDomainRequest(input) + err := req.Send() + return out, err +} + +const opRenewDomain = "RenewDomain" + +// RenewDomainRequest generates a "aws/request.Request" representing the +// client's request for the RenewDomain operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the RenewDomain method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the RenewDomainRequest method. +// req, resp := client.RenewDomainRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) RenewDomainRequest(input *RenewDomainInput) (req *request.Request, output *RenewDomainOutput) { + op := &request.Operation{ + Name: opRenewDomain, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RenewDomainInput{} + } + + req = c.newRequest(op, input, output) + output = &RenewDomainOutput{} + req.Data = output + return +} + +// This operation renews a domain for the specified number of years. The cost +// of renewing your domain is billed to your AWS account. +// +// We recommend that you renew your domain several weeks before the expiration +// date. Some TLD registries delete domains before the expiration date if you +// haven't renewed far enough in advance. For more information about renewing +// domain registration, see Renewing Registration for a Domain (http://docs.aws.amazon.com/console/route53/domain-renew) +// in the Amazon Route 53 documentation. +func (c *Route53Domains) RenewDomain(input *RenewDomainInput) (*RenewDomainOutput, error) { + req, out := c.RenewDomainRequest(input) + err := req.Send() + return out, err +} + +const opResendContactReachabilityEmail = "ResendContactReachabilityEmail" + +// ResendContactReachabilityEmailRequest generates a "aws/request.Request" representing the +// client's request for the ResendContactReachabilityEmail operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the ResendContactReachabilityEmail method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the ResendContactReachabilityEmailRequest method. +// req, resp := client.ResendContactReachabilityEmailRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) ResendContactReachabilityEmailRequest(input *ResendContactReachabilityEmailInput) (req *request.Request, output *ResendContactReachabilityEmailOutput) { + op := &request.Operation{ + Name: opResendContactReachabilityEmail, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ResendContactReachabilityEmailInput{} + } + + req = c.newRequest(op, input, output) + output = &ResendContactReachabilityEmailOutput{} + req.Data = output + return +} + +// For operations that require confirmation that the email address for the registrant +// contact is valid, such as registering a new domain, this operation resends +// the confirmation email to the current email address for the registrant contact. +func (c *Route53Domains) ResendContactReachabilityEmail(input *ResendContactReachabilityEmailInput) (*ResendContactReachabilityEmailOutput, error) { + req, out := c.ResendContactReachabilityEmailRequest(input) + err := req.Send() + return out, err +} + +const opRetrieveDomainAuthCode = "RetrieveDomainAuthCode" + +// RetrieveDomainAuthCodeRequest generates a "aws/request.Request" representing the +// client's request for the RetrieveDomainAuthCode operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the RetrieveDomainAuthCode method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the RetrieveDomainAuthCodeRequest method. +// req, resp := client.RetrieveDomainAuthCodeRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) RetrieveDomainAuthCodeRequest(input *RetrieveDomainAuthCodeInput) (req *request.Request, output *RetrieveDomainAuthCodeOutput) { + op := &request.Operation{ + Name: opRetrieveDomainAuthCode, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RetrieveDomainAuthCodeInput{} + } + + req = c.newRequest(op, input, output) + output = &RetrieveDomainAuthCodeOutput{} + req.Data = output + return +} + +// This operation returns the AuthCode for the domain. To transfer a domain +// to another registrar, you provide this value to the new registrar. +func (c *Route53Domains) RetrieveDomainAuthCode(input *RetrieveDomainAuthCodeInput) (*RetrieveDomainAuthCodeOutput, error) { + req, out := c.RetrieveDomainAuthCodeRequest(input) + err := req.Send() + return out, err +} + +const opTransferDomain = "TransferDomain" + +// TransferDomainRequest generates a "aws/request.Request" representing the +// client's request for the TransferDomain operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the TransferDomain method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the TransferDomainRequest method. +// req, resp := client.TransferDomainRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) TransferDomainRequest(input *TransferDomainInput) (req *request.Request, output *TransferDomainOutput) { + op := &request.Operation{ + Name: opTransferDomain, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &TransferDomainInput{} + } + + req = c.newRequest(op, input, output) + output = &TransferDomainOutput{} + req.Data = output + return +} + +// This operation transfers a domain from another registrar to Amazon Route +// 53. When the transfer is complete, the domain is registered with the AWS +// registrar partner, Gandi. +// +// For transfer requirements, a detailed procedure, and information about viewing +// the status of a domain transfer, see Transferring Registration for a Domain +// to Amazon Route 53 (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/domain-transfer-to-route-53.html) +// in the Amazon Route 53 Developer Guide. +// +// If the registrar for your domain is also the DNS service provider for the +// domain, we highly recommend that you consider transferring your DNS service +// to Amazon Route 53 or to another DNS service provider before you transfer +// your registration. Some registrars provide free DNS service when you purchase +// a domain registration. When you transfer the registration, the previous registrar +// will not renew your domain registration and could end your DNS service at +// any time. +// +// Caution! If the registrar for your domain is also the DNS service provider +// for the domain and you don't transfer DNS service to another provider, your +// website, email, and the web applications associated with the domain might +// become unavailable. If the transfer is successful, this method returns an +// operation ID that you can use to track the progress and completion of the +// action. If the transfer doesn't complete successfully, the domain registrant +// will be notified by email. +func (c *Route53Domains) TransferDomain(input *TransferDomainInput) (*TransferDomainOutput, error) { + req, out := c.TransferDomainRequest(input) + err := req.Send() + return out, err +} + +const opUpdateDomainContact = "UpdateDomainContact" + +// UpdateDomainContactRequest generates a "aws/request.Request" representing the +// client's request for the UpdateDomainContact operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the UpdateDomainContact method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the UpdateDomainContactRequest method. +// req, resp := client.UpdateDomainContactRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) UpdateDomainContactRequest(input *UpdateDomainContactInput) (req *request.Request, output *UpdateDomainContactOutput) { + op := &request.Operation{ + Name: opUpdateDomainContact, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateDomainContactInput{} + } + + req = c.newRequest(op, input, output) + output = &UpdateDomainContactOutput{} + req.Data = output + return +} + +// This operation updates the contact information for a particular domain. Information +// for at least one contact (registrant, administrator, or technical) must be +// supplied for update. +// +// If the update is successful, this method returns an operation ID that you +// can use to track the progress and completion of the action. If the request +// is not completed successfully, the domain registrant will be notified by +// email. +func (c *Route53Domains) UpdateDomainContact(input *UpdateDomainContactInput) (*UpdateDomainContactOutput, error) { + req, out := c.UpdateDomainContactRequest(input) + err := req.Send() + return out, err +} + +const opUpdateDomainContactPrivacy = "UpdateDomainContactPrivacy" + +// UpdateDomainContactPrivacyRequest generates a "aws/request.Request" representing the +// client's request for the UpdateDomainContactPrivacy operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the UpdateDomainContactPrivacy method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the UpdateDomainContactPrivacyRequest method. +// req, resp := client.UpdateDomainContactPrivacyRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) UpdateDomainContactPrivacyRequest(input *UpdateDomainContactPrivacyInput) (req *request.Request, output *UpdateDomainContactPrivacyOutput) { + op := &request.Operation{ + Name: opUpdateDomainContactPrivacy, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateDomainContactPrivacyInput{} + } + + req = c.newRequest(op, input, output) + output = &UpdateDomainContactPrivacyOutput{} + req.Data = output + return +} + +// This operation updates the specified domain contact's privacy setting. When +// the privacy option is enabled, personal information such as postal or email +// address is hidden from the results of a public WHOIS query. The privacy services +// are provided by the AWS registrar, Gandi. For more information, see the Gandi +// privacy features (http://www.gandi.net/domain/whois/?currency=USD&lang=en). +// +// This operation only affects the privacy of the specified contact type (registrant, +// administrator, or tech). Successful acceptance returns an operation ID that +// you can use with GetOperationDetail to track the progress and completion +// of the action. If the request is not completed successfully, the domain registrant +// will be notified by email. +func (c *Route53Domains) UpdateDomainContactPrivacy(input *UpdateDomainContactPrivacyInput) (*UpdateDomainContactPrivacyOutput, error) { + req, out := c.UpdateDomainContactPrivacyRequest(input) + err := req.Send() + return out, err +} + +const opUpdateDomainNameservers = "UpdateDomainNameservers" + +// UpdateDomainNameserversRequest generates a "aws/request.Request" representing the +// client's request for the UpdateDomainNameservers operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the UpdateDomainNameservers method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the UpdateDomainNameserversRequest method. +// req, resp := client.UpdateDomainNameserversRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) UpdateDomainNameserversRequest(input *UpdateDomainNameserversInput) (req *request.Request, output *UpdateDomainNameserversOutput) { + op := &request.Operation{ + Name: opUpdateDomainNameservers, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateDomainNameserversInput{} + } + + req = c.newRequest(op, input, output) + output = &UpdateDomainNameserversOutput{} + req.Data = output + return +} + +// This operation replaces the current set of name servers for the domain with +// the specified set of name servers. If you use Amazon Route 53 as your DNS +// service, specify the four name servers in the delegation set for the hosted +// zone for the domain. +// +// If successful, this operation returns an operation ID that you can use to +// track the progress and completion of the action. If the request is not completed +// successfully, the domain registrant will be notified by email. +func (c *Route53Domains) UpdateDomainNameservers(input *UpdateDomainNameserversInput) (*UpdateDomainNameserversOutput, error) { + req, out := c.UpdateDomainNameserversRequest(input) + err := req.Send() + return out, err +} + +const opUpdateTagsForDomain = "UpdateTagsForDomain" + +// UpdateTagsForDomainRequest generates a "aws/request.Request" representing the +// client's request for the UpdateTagsForDomain operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the UpdateTagsForDomain method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the UpdateTagsForDomainRequest method. +// req, resp := client.UpdateTagsForDomainRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) UpdateTagsForDomainRequest(input *UpdateTagsForDomainInput) (req *request.Request, output *UpdateTagsForDomainOutput) { + op := &request.Operation{ + Name: opUpdateTagsForDomain, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateTagsForDomainInput{} + } + + req = c.newRequest(op, input, output) + output = &UpdateTagsForDomainOutput{} + req.Data = output + return +} + +// This operation adds or updates tags for a specified domain. +// +// All tag operations are eventually consistent; subsequent operations may +// not immediately represent all issued operations. +func (c *Route53Domains) UpdateTagsForDomain(input *UpdateTagsForDomainInput) (*UpdateTagsForDomainOutput, error) { + req, out := c.UpdateTagsForDomainRequest(input) + err := req.Send() + return out, err +} + +const opViewBilling = "ViewBilling" + +// ViewBillingRequest generates a "aws/request.Request" representing the +// client's request for the ViewBilling operation. The "output" return +// value can be used to capture response data after the request's "Send" method +// is called. +// +// Creating a request object using this method should be used when you want to inject +// custom logic into the request's lifecycle using a custom handler, or if you want to +// access properties on the request object before or after sending the request. If +// you just want the service response, call the ViewBilling method directly +// instead. +// +// Note: You must call the "Send" method on the returned request object in order +// to execute the request. +// +// // Example sending a request using the ViewBillingRequest method. +// req, resp := client.ViewBillingRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +func (c *Route53Domains) ViewBillingRequest(input *ViewBillingInput) (req *request.Request, output *ViewBillingOutput) { + op := &request.Operation{ + Name: opViewBilling, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ViewBillingInput{} + } + + req = c.newRequest(op, input, output) + output = &ViewBillingOutput{} + req.Data = output + return +} + +// This operation returns all the domain-related billing records for the current +// AWS account for a specified period +func (c *Route53Domains) ViewBilling(input *ViewBillingInput) (*ViewBillingOutput, error) { + req, out := c.ViewBillingRequest(input) + err := req.Send() + return out, err +} + +type BillingRecord struct { + _ struct{} `type:"structure"` + + // The date that the operation was billed, in Unix format. + // + // Type: Double + BillDate *time.Time `type:"timestamp" timestampFormat:"unix"` + + // The name of a domain. + // + // Type: String + DomainName *string `type:"string"` + + // The ID of the invoice that is associated with the billing record. + // + // Type: String + InvoiceId *string `type:"string"` + + // The operation that you were charged for. + // + // Type: String + // + // Valid values: REGISTER_DOMAIN TRANSFER_IN_DOMAIN RENEW_DOMAIN CHANGE_DOMAIN_OWNER + Operation *string `type:"string" enum:"OperationType"` + + // The price that you were charged for the operation, in US dollars. + // + // Type: Double + // + // Example value: 12.0 + Price *float64 `type:"double"` +} + +// String returns the string representation +func (s BillingRecord) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s BillingRecord) GoString() string { + return s.String() +} + +// The CheckDomainAvailability request contains the following elements. +type CheckDomainAvailabilityInput struct { + _ struct{} `type:"structure"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // Reserved for future use. + IdnLangCode *string `type:"string"` +} + +// String returns the string representation +func (s CheckDomainAvailabilityInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CheckDomainAvailabilityInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *CheckDomainAvailabilityInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "CheckDomainAvailabilityInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The CheckDomainAvailability response includes the following elements. +type CheckDomainAvailabilityOutput struct { + _ struct{} `type:"structure"` + + // Whether the domain name is available for registering. + // + // You can only register domains designated as AVAILABLE. + // + // Type: String + // + // Valid values: + // + // AVAILABLE – The domain name is available. AVAILABLE_RESERVED – The domain + // name is reserved under specific conditions. AVAILABLE_PREORDER – The domain + // name is available and can be preordered. UNAVAILABLE – The domain name is + // not available. UNAVAILABLE_PREMIUM – The domain name is not available. UNAVAILABLE_RESTRICTED + // – The domain name is forbidden. RESERVED – The domain name has been reserved + // for another person or organization. DONT_KNOW – The TLD registry didn't reply + // with a definitive answer about whether the domain name is available. Amazon + // Route 53 can return this response for a variety of reasons, for example, + // the registry is performing maintenance. Try again later. + Availability *string `type:"string" required:"true" enum:"DomainAvailability"` +} + +// String returns the string representation +func (s CheckDomainAvailabilityOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CheckDomainAvailabilityOutput) GoString() string { + return s.String() +} + +// ContactDetail includes the following elements. +type ContactDetail struct { + _ struct{} `type:"structure"` + + // First line of the contact's address. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + AddressLine1 *string `type:"string"` + + // Second line of contact's address, if any. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: No + AddressLine2 *string `type:"string"` + + // The city of the contact's address. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + City *string `type:"string"` + + // Indicates whether the contact is a person, company, association, or public + // organization. If you choose an option other than PERSON, you must enter an + // organization name, and you can't enable privacy protection for the contact. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Valid values: PERSON | COMPANY | ASSOCIATION | PUBLIC_BODY + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + ContactType *string `type:"string" enum:"ContactType"` + + // Code for the country of the contact's address. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + CountryCode *string `type:"string" enum:"CountryCode"` + + // Email address of the contact. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 254 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + Email *string `type:"string"` + + // A list of name-value pairs for parameters required by certain top-level domains. + // + // Type: Complex + // + // Default: None + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Children: Name, Value + // + // Required: No + ExtraParams []*ExtraParam `type:"list"` + + // Fax number of the contact. + // + // Type: String + // + // Default: None + // + // Constraints: Phone number must be specified in the format "+[country dialing + // code].[number including any area code]". For example, a US phone number might + // appear as "+1.1234567890". + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: No + Fax *string `type:"string"` + + // First name of contact. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + FirstName *string `type:"string"` + + // Last name of contact. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + LastName *string `type:"string"` + + // Name of the organization for contact types other than PERSON. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. Contact type must not be PERSON. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: No + OrganizationName *string `type:"string"` + + // The phone number of the contact. + // + // Type: String + // + // Default: None + // + // Constraints: Phone number must be specified in the format "+[country dialing + // code].[number including any area code>]". For example, a US phone number + // might appear as "+1.1234567890". + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: Yes + PhoneNumber *string `type:"string"` + + // The state or province of the contact's city. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: No + State *string `type:"string"` + + // The zip or postal code of the contact's address. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + // + // Parents: RegistrantContact, AdminContact, TechContact + // + // Required: No + ZipCode *string `type:"string"` +} + +// String returns the string representation +func (s ContactDetail) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ContactDetail) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ContactDetail) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ContactDetail"} + if s.ExtraParams != nil { + for i, v := range s.ExtraParams { + if v == nil { + continue + } + if err := v.Validate(); err != nil { + invalidParams.AddNested(fmt.Sprintf("%s[%v]", "ExtraParams", i), err.(request.ErrInvalidParams)) + } + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The DeleteTagsForDomainRequest includes the following elements. +type DeleteTagsForDomainInput struct { + _ struct{} `type:"structure"` + + // The domain for which you want to delete one or more tags. + // + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Hyphens are allowed only when they're + // surrounded by letters, numbers, or other hyphens. You can't specify a hyphen + // at the beginning or end of a label. To specify an Internationalized Domain + // Name, you must convert the name to Punycode. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // A list of tag keys to delete. + // + // Type: A list that contains the keys of the tags that you want to delete. + // + // Default: None + // + // Required: No + // + // '> + TagsToDelete []*string `type:"list" required:"true"` +} + +// String returns the string representation +func (s DeleteTagsForDomainInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteTagsForDomainInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DeleteTagsForDomainInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DeleteTagsForDomainInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + if s.TagsToDelete == nil { + invalidParams.Add(request.NewErrParamRequired("TagsToDelete")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +type DeleteTagsForDomainOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DeleteTagsForDomainOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteTagsForDomainOutput) GoString() string { + return s.String() +} + +type DisableDomainAutoRenewInput struct { + _ struct{} `type:"structure"` + + DomainName *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s DisableDomainAutoRenewInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DisableDomainAutoRenewInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DisableDomainAutoRenewInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DisableDomainAutoRenewInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +type DisableDomainAutoRenewOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DisableDomainAutoRenewOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DisableDomainAutoRenewOutput) GoString() string { + return s.String() +} + +// The DisableDomainTransferLock request includes the following element. +type DisableDomainTransferLockInput struct { + _ struct{} `type:"structure"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s DisableDomainTransferLockInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DisableDomainTransferLockInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DisableDomainTransferLockInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DisableDomainTransferLockInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The DisableDomainTransferLock response includes the following element. +type DisableDomainTransferLockOutput struct { + _ struct{} `type:"structure"` + + // Identifier for tracking the progress of the request. To use this ID to query + // the operation status, use GetOperationDetail. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s DisableDomainTransferLockOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DisableDomainTransferLockOutput) GoString() string { + return s.String() +} + +type DomainSuggestion struct { + _ struct{} `type:"structure"` + + Availability *string `type:"string"` + + DomainName *string `type:"string"` +} + +// String returns the string representation +func (s DomainSuggestion) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DomainSuggestion) GoString() string { + return s.String() +} + +type DomainSummary struct { + _ struct{} `type:"structure"` + + // Indicates whether the domain is automatically renewed upon expiration. + // + // Type: Boolean + // + // Valid values: True | False + AutoRenew *bool `type:"boolean"` + + // The name of a domain. + // + // Type: String + DomainName *string `type:"string" required:"true"` + + // Expiration date of the domain in Coordinated Universal Time (UTC). + // + // Type: Long + Expiry *time.Time `type:"timestamp" timestampFormat:"unix"` + + // Indicates whether a domain is locked from unauthorized transfer to another + // party. + // + // Type: Boolean + // + // Valid values: True | False + TransferLock *bool `type:"boolean"` +} + +// String returns the string representation +func (s DomainSummary) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DomainSummary) GoString() string { + return s.String() +} + +type EnableDomainAutoRenewInput struct { + _ struct{} `type:"structure"` + + DomainName *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s EnableDomainAutoRenewInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnableDomainAutoRenewInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *EnableDomainAutoRenewInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "EnableDomainAutoRenewInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +type EnableDomainAutoRenewOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s EnableDomainAutoRenewOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnableDomainAutoRenewOutput) GoString() string { + return s.String() +} + +// The EnableDomainTransferLock request includes the following element. +type EnableDomainTransferLockInput struct { + _ struct{} `type:"structure"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s EnableDomainTransferLockInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnableDomainTransferLockInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *EnableDomainTransferLockInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "EnableDomainTransferLockInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The EnableDomainTransferLock response includes the following elements. +type EnableDomainTransferLockOutput struct { + _ struct{} `type:"structure"` + + // Identifier for tracking the progress of the request. To use this ID to query + // the operation status, use GetOperationDetail. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s EnableDomainTransferLockOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnableDomainTransferLockOutput) GoString() string { + return s.String() +} + +// ExtraParam includes the following elements. +type ExtraParam struct { + _ struct{} `type:"structure"` + + // Name of the additional parameter required by the top-level domain. + // + // Type: String + // + // Default: None + // + // Valid values: DUNS_NUMBER | BRAND_NUMBER | BIRTH_DEPARTMENT | BIRTH_DATE_IN_YYYY_MM_DD + // | BIRTH_COUNTRY | BIRTH_CITY | DOCUMENT_NUMBER | AU_ID_NUMBER | AU_ID_TYPE + // | CA_LEGAL_TYPE | CA_BUSINESS_ENTITY_TYPE |ES_IDENTIFICATION | ES_IDENTIFICATION_TYPE + // | ES_LEGAL_FORM | FI_BUSINESS_NUMBER | FI_ID_NUMBER | IT_PIN | RU_PASSPORT_DATA + // | SE_ID_NUMBER | SG_ID_NUMBER | VAT_NUMBER + // + // Parent: ExtraParams + // + // Required: Yes + Name *string `type:"string" required:"true" enum:"ExtraParamName"` + + // Values corresponding to the additional parameter names required by some top-level + // domains. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 2048 characters. + // + // Parent: ExtraParams + // + // Required: Yes + Value *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s ExtraParam) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ExtraParam) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ExtraParam) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ExtraParam"} + if s.Name == nil { + invalidParams.Add(request.NewErrParamRequired("Name")) + } + if s.Value == nil { + invalidParams.Add(request.NewErrParamRequired("Value")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +type GetContactReachabilityStatusInput struct { + _ struct{} `type:"structure"` + + // The name of the domain for which you want to know whether the registrant + // contact has confirmed that the email address is valid. + // + // Type: String + // + // Default: None + // + // Required: Yes + DomainName *string `locationName:"domainName" type:"string"` +} + +// String returns the string representation +func (s GetContactReachabilityStatusInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetContactReachabilityStatusInput) GoString() string { + return s.String() +} + +type GetContactReachabilityStatusOutput struct { + _ struct{} `type:"structure"` + + // The domain name for which you requested the reachability status. + DomainName *string `locationName:"domainName" type:"string"` + + // Whether the registrant contact has responded. PENDING indicates that we sent + // the confirmation email and haven't received a response yet, DONE indicates + // that we sent the email and got confirmation from the registrant contact, + // and EXPIRED indicates that the time limit expired before the registrant contact + // responded. + // + // Type: String + // + // Valid values: PENDING, DONE, EXPIRED + Status *string `locationName:"status" type:"string" enum:"ReachabilityStatus"` +} + +// String returns the string representation +func (s GetContactReachabilityStatusOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetContactReachabilityStatusOutput) GoString() string { + return s.String() +} + +// The GetDomainDetail request includes the following element. +type GetDomainDetailInput struct { + _ struct{} `type:"structure"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s GetDomainDetailInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetDomainDetailInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetDomainDetailInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "GetDomainDetailInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The GetDomainDetail response includes the following elements. +type GetDomainDetailOutput struct { + _ struct{} `type:"structure"` + + // Email address to contact to report incorrect contact information for a domain, + // to report that the domain is being used to send spam, to report that someone + // is cybersquatting on a domain name, or report some other type of abuse. + // + // Type: String + AbuseContactEmail *string `type:"string"` + + // Phone number for reporting abuse. + // + // Type: String + AbuseContactPhone *string `type:"string"` + + // Provides details about the domain administrative contact. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + AdminContact *ContactDetail `type:"structure" required:"true"` + + // Specifies whether contact information for the admin contact is concealed + // from WHOIS queries. If the value is true, WHOIS ("who is") queries will return + // contact information for our registrar partner, Gandi, instead of the contact + // information that you enter. + // + // Type: Boolean + AdminPrivacy *bool `type:"boolean"` + + // Specifies whether the domain registration is set to renew automatically. + // + // Type: Boolean + AutoRenew *bool `type:"boolean"` + + // The date when the domain was created as found in the response to a WHOIS + // query. The date format is Unix time. + CreationDate *time.Time `type:"timestamp" timestampFormat:"unix"` + + // Reserved for future use. + DnsSec *string `type:"string"` + + // The name of a domain. + // + // Type: String + DomainName *string `type:"string" required:"true"` + + // The date when the registration for the domain is set to expire. The date + // format is Unix time. + ExpirationDate *time.Time `type:"timestamp" timestampFormat:"unix"` + + // The name of the domain. + // + // Type: String + Nameservers []*Nameserver `type:"list" required:"true"` + + // Provides details about the domain registrant. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + RegistrantContact *ContactDetail `type:"structure" required:"true"` + + // Specifies whether contact information for the registrant contact is concealed + // from WHOIS queries. If the value is true, WHOIS ("who is") queries will return + // contact information for our registrar partner, Gandi, instead of the contact + // information that you enter. + // + // Type: Boolean + RegistrantPrivacy *bool `type:"boolean"` + + // Name of the registrar of the domain as identified in the registry. Amazon + // Route 53 domains are registered by registrar Gandi. The value is "GANDI SAS". + // + // Type: String + RegistrarName *string `type:"string"` + + // Web address of the registrar. + // + // Type: String + RegistrarUrl *string `type:"string"` + + // Reserved for future use. + RegistryDomainId *string `type:"string"` + + // Reseller of the domain. Domains registered or transferred using Amazon Route + // 53 domains will have "Amazon" as the reseller. + // + // Type: String + Reseller *string `type:"string"` + + // An array of domain name status codes, also known as Extensible Provisioning + // Protocol (EPP) status codes. + // + // ICANN, the organization that maintains a central database of domain names, + // has developed a set of domain name status codes that tell you the status + // of a variety of operations on a domain name, for example, registering a domain + // name, transferring a domain name to another registrar, renewing the registration + // for a domain name, and so on. All registrars use this same set of status + // codes. + // + // For a current list of domain name status codes and an explanation of what + // each code means, go to the ICANN website (https://www.icann.org/) and search + // for epp status codes. (Search on the ICANN website; web searches sometimes + // return an old version of the document.) + // + // Type: Array of String + StatusList []*string `type:"list"` + + // Provides details about the domain technical contact. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + TechContact *ContactDetail `type:"structure" required:"true"` + + // Specifies whether contact information for the tech contact is concealed from + // WHOIS queries. If the value is true, WHOIS ("who is") queries will return + // contact information for our registrar partner, Gandi, instead of the contact + // information that you enter. + // + // Type: Boolean + TechPrivacy *bool `type:"boolean"` + + // The last updated date of the domain as found in the response to a WHOIS query. + // The date format is Unix time. + UpdatedDate *time.Time `type:"timestamp" timestampFormat:"unix"` + + // The fully qualified name of the WHOIS server that can answer the WHOIS query + // for the domain. + // + // Type: String + WhoIsServer *string `type:"string"` +} + +// String returns the string representation +func (s GetDomainDetailOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetDomainDetailOutput) GoString() string { + return s.String() +} + +type GetDomainSuggestionsInput struct { + _ struct{} `type:"structure"` + + DomainName *string `type:"string" required:"true"` + + OnlyAvailable *bool `type:"boolean" required:"true"` + + SuggestionCount *int64 `type:"integer" required:"true"` +} + +// String returns the string representation +func (s GetDomainSuggestionsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetDomainSuggestionsInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetDomainSuggestionsInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "GetDomainSuggestionsInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + if s.OnlyAvailable == nil { + invalidParams.Add(request.NewErrParamRequired("OnlyAvailable")) + } + if s.SuggestionCount == nil { + invalidParams.Add(request.NewErrParamRequired("SuggestionCount")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +type GetDomainSuggestionsOutput struct { + _ struct{} `type:"structure"` + + SuggestionsList []*DomainSuggestion `type:"list"` +} + +// String returns the string representation +func (s GetDomainSuggestionsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetDomainSuggestionsOutput) GoString() string { + return s.String() +} + +// The GetOperationDetail request includes the following element. +type GetOperationDetailInput struct { + _ struct{} `type:"structure"` + + // The identifier for the operation for which you want to get the status. Amazon + // Route 53 returned the identifier in the response to the original request. + // + // Type: String + // + // Default: None + // + // Required: Yes + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s GetOperationDetailInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetOperationDetailInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetOperationDetailInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "GetOperationDetailInput"} + if s.OperationId == nil { + invalidParams.Add(request.NewErrParamRequired("OperationId")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The GetOperationDetail response includes the following elements. +type GetOperationDetailOutput struct { + _ struct{} `type:"structure"` + + // The name of a domain. + // + // Type: String + DomainName *string `type:"string"` + + // Detailed information on the status including possible errors. + // + // Type: String + Message *string `type:"string"` + + // The identifier for the operation. + // + // Type: String + OperationId *string `type:"string"` + + // The current status of the requested operation in the system. + // + // Type: String + Status *string `type:"string" enum:"OperationStatus"` + + // The date when the request was submitted. + SubmittedDate *time.Time `type:"timestamp" timestampFormat:"unix"` + + // The type of operation that was requested. + // + // Type: String + Type *string `type:"string" enum:"OperationType"` +} + +// String returns the string representation +func (s GetOperationDetailOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetOperationDetailOutput) GoString() string { + return s.String() +} + +// The ListDomains request includes the following elements. +type ListDomainsInput struct { + _ struct{} `type:"structure"` + + // For an initial request for a list of domains, omit this element. If the number + // of domains that are associated with the current AWS account is greater than + // the value that you specified for MaxItems, you can use Marker to return additional + // domains. Get the value of NextPageMarker from the previous response, and + // submit another request that includes the value of NextPageMarker in the Marker + // element. + // + // Type: String + // + // Default: None + // + // Constraints: The marker must match the value specified in the previous request. + // + // Required: No + Marker *string `type:"string"` + + // Number of domains to be returned. + // + // Type: Integer + // + // Default: 20 + // + // Constraints: A numeral between 1 and 100. + // + // Required: No + MaxItems *int64 `type:"integer"` +} + +// String returns the string representation +func (s ListDomainsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListDomainsInput) GoString() string { + return s.String() +} + +// The ListDomains response includes the following elements. +type ListDomainsOutput struct { + _ struct{} `type:"structure"` + + // A summary of domains. + // + // Type: Complex type containing a list of domain summaries. + // + // Children: AutoRenew, DomainName, Expiry, TransferLock + Domains []*DomainSummary `type:"list" required:"true"` + + // If there are more domains than you specified for MaxItems in the request, + // submit another request and include the value of NextPageMarker in the value + // of Marker. + // + // Type: String + // + // Parent: Operations + NextPageMarker *string `type:"string"` +} + +// String returns the string representation +func (s ListDomainsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListDomainsOutput) GoString() string { + return s.String() +} + +// The ListOperations request includes the following elements. +type ListOperationsInput struct { + _ struct{} `type:"structure"` + + // For an initial request for a list of operations, omit this element. If the + // number of operations that are not yet complete is greater than the value + // that you specified for MaxItems, you can use Marker to return additional + // operations. Get the value of NextPageMarker from the previous response, and + // submit another request that includes the value of NextPageMarker in the Marker + // element. + // + // Type: String + // + // Default: None + // + // Required: No + Marker *string `type:"string"` + + // Number of domains to be returned. + // + // Type: Integer + // + // Default: 20 + // + // Constraints: A value between 1 and 100. + // + // Required: No + MaxItems *int64 `type:"integer"` +} + +// String returns the string representation +func (s ListOperationsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListOperationsInput) GoString() string { + return s.String() +} + +// The ListOperations response includes the following elements. +type ListOperationsOutput struct { + _ struct{} `type:"structure"` + + // If there are more operations than you specified for MaxItems in the request, + // submit another request and include the value of NextPageMarker in the value + // of Marker. + // + // Type: String + // + // Parent: Operations + NextPageMarker *string `type:"string"` + + // Lists summaries of the operations. + // + // Type: Complex type containing a list of operation summaries + // + // Children: OperationId, Status, SubmittedDate, Type + Operations []*OperationSummary `type:"list" required:"true"` +} + +// String returns the string representation +func (s ListOperationsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListOperationsOutput) GoString() string { + return s.String() +} + +// The ListTagsForDomainRequest includes the following elements. +type ListTagsForDomainInput struct { + _ struct{} `type:"structure"` + + // The domain for which you want to get a list of tags. + DomainName *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s ListTagsForDomainInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListTagsForDomainInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ListTagsForDomainInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ListTagsForDomainInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The ListTagsForDomain response includes the following elements. +type ListTagsForDomainOutput struct { + _ struct{} `type:"structure"` + + // A list of the tags that are associated with the specified domain. + // + // Type: A complex type containing a list of tags + // + // Each tag includes the following elements. + // + // Key + // + // The key (name) of a tag. + // + // Type: String + // + // Value + // + // The value of a tag. + // + // Type: String + TagList []*Tag `type:"list" required:"true"` +} + +// String returns the string representation +func (s ListTagsForDomainOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListTagsForDomainOutput) GoString() string { + return s.String() +} + +// Nameserver includes the following elements. +type Nameserver struct { + _ struct{} `type:"structure"` + + // Glue IP address of a name server entry. Glue IP addresses are required only + // when the name of the name server is a subdomain of the domain. For example, + // if your domain is example.com and the name server for the domain is ns.example.com, + // you need to specify the IP address for ns.example.com. + // + // Type: List of IP addresses. + // + // Constraints: The list can contain only one IPv4 and one IPv6 address. + // + // Parent: Nameservers + GlueIps []*string `type:"list"` + + // The fully qualified host name of the name server. + // + // Type: String + // + // Constraint: Maximum 255 characterss + // + // Parent: Nameservers + Name *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s Nameserver) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Nameserver) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *Nameserver) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "Nameserver"} + if s.Name == nil { + invalidParams.Add(request.NewErrParamRequired("Name")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// OperationSummary includes the following elements. +type OperationSummary struct { + _ struct{} `type:"structure"` + + // Identifier returned to track the requested action. + // + // Type: String + OperationId *string `type:"string" required:"true"` + + // The current status of the requested operation in the system. + // + // Type: String + Status *string `type:"string" required:"true" enum:"OperationStatus"` + + // The date when the request was submitted. + SubmittedDate *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"` + + // Type of the action requested. + // + // Type: String + // + // Valid values: REGISTER_DOMAIN | DELETE_DOMAIN | TRANSFER_IN_DOMAIN | UPDATE_DOMAIN_CONTACT + // | UPDATE_NAMESERVER | CHANGE_PRIVACY_PROTECTION | DOMAIN_LOCK + Type *string `type:"string" required:"true" enum:"OperationType"` +} + +// String returns the string representation +func (s OperationSummary) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s OperationSummary) GoString() string { + return s.String() +} + +// The RegisterDomain request includes the following elements. +type RegisterDomainInput struct { + _ struct{} `type:"structure"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + AdminContact *ContactDetail `type:"structure" required:"true"` + + // Indicates whether the domain will be automatically renewed (true) or not + // (false). Autorenewal only takes effect after the account is charged. + // + // Type: Boolean + // + // Valid values: true | false + // + // Default: true + // + // Required: No + AutoRenew *bool `type:"boolean"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // The number of years the domain will be registered. Domains are registered + // for a minimum of one year. The maximum period depends on the top-level domain. + // + // Type: Integer + // + // Default: 1 + // + // Valid values: Integer from 1 to 10 + // + // Required: Yes + DurationInYears *int64 `min:"1" type:"integer" required:"true"` + + // Reserved for future use. + IdnLangCode *string `type:"string"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: true + // + // Valid values: true | false + // + // Required: No + PrivacyProtectAdminContact *bool `type:"boolean"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: true + // + // Valid values: true | false + // + // Required: No + PrivacyProtectRegistrantContact *bool `type:"boolean"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: true + // + // Valid values: true | false + // + // Required: No + PrivacyProtectTechContact *bool `type:"boolean"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + RegistrantContact *ContactDetail `type:"structure" required:"true"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + TechContact *ContactDetail `type:"structure" required:"true"` +} + +// String returns the string representation +func (s RegisterDomainInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RegisterDomainInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *RegisterDomainInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "RegisterDomainInput"} + if s.AdminContact == nil { + invalidParams.Add(request.NewErrParamRequired("AdminContact")) + } + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + if s.DurationInYears == nil { + invalidParams.Add(request.NewErrParamRequired("DurationInYears")) + } + if s.DurationInYears != nil && *s.DurationInYears < 1 { + invalidParams.Add(request.NewErrParamMinValue("DurationInYears", 1)) + } + if s.RegistrantContact == nil { + invalidParams.Add(request.NewErrParamRequired("RegistrantContact")) + } + if s.TechContact == nil { + invalidParams.Add(request.NewErrParamRequired("TechContact")) + } + if s.AdminContact != nil { + if err := s.AdminContact.Validate(); err != nil { + invalidParams.AddNested("AdminContact", err.(request.ErrInvalidParams)) + } + } + if s.RegistrantContact != nil { + if err := s.RegistrantContact.Validate(); err != nil { + invalidParams.AddNested("RegistrantContact", err.(request.ErrInvalidParams)) + } + } + if s.TechContact != nil { + if err := s.TechContact.Validate(); err != nil { + invalidParams.AddNested("TechContact", err.(request.ErrInvalidParams)) + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The RegisterDomain response includes the following element. +type RegisterDomainOutput struct { + _ struct{} `type:"structure"` + + // Identifier for tracking the progress of the request. To use this ID to query + // the operation status, use GetOperationDetail. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s RegisterDomainOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RegisterDomainOutput) GoString() string { + return s.String() +} + +// A RenewDomain request includes the number of years that you want to renew +// for and the current expiration year. +type RenewDomainInput struct { + _ struct{} `type:"structure"` + + // The year when the registration for the domain is set to expire. This value + // must match the current expiration date for the domain. + // + // Type: Integer + // + // Default: None + // + // Valid values: Integer + // + // Required: Yes + CurrentExpiryYear *int64 `type:"integer" required:"true"` + + DomainName *string `type:"string" required:"true"` + + // The number of years that you want to renew the domain for. The maximum number + // of years depends on the top-level domain. For the range of valid values for + // your domain, see Domains that You Can Register with Amazon Route 53 (http://docs.aws.amazon.com/console/route53/domain-tld-list) + // in the Amazon Route 53 documentation. + // + // Type: Integer + // + // Default: 1 + // + // Valid values: Integer from 1 to 10 + // + // Required: No + DurationInYears *int64 `min:"1" type:"integer"` +} + +// String returns the string representation +func (s RenewDomainInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RenewDomainInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *RenewDomainInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "RenewDomainInput"} + if s.CurrentExpiryYear == nil { + invalidParams.Add(request.NewErrParamRequired("CurrentExpiryYear")) + } + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + if s.DurationInYears != nil && *s.DurationInYears < 1 { + invalidParams.Add(request.NewErrParamMinValue("DurationInYears", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +type RenewDomainOutput struct { + _ struct{} `type:"structure"` + + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s RenewDomainOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RenewDomainOutput) GoString() string { + return s.String() +} + +type ResendContactReachabilityEmailInput struct { + _ struct{} `type:"structure"` + + // The name of the domain for which you want Amazon Route 53 to resend a confirmation + // email to the registrant contact. + // + // Type: String + // + // Default: None + // + // Required: Yes + DomainName *string `locationName:"domainName" type:"string"` +} + +// String returns the string representation +func (s ResendContactReachabilityEmailInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ResendContactReachabilityEmailInput) GoString() string { + return s.String() +} + +type ResendContactReachabilityEmailOutput struct { + _ struct{} `type:"structure"` + + // The domain name for which you requested a confirmation email. + DomainName *string `locationName:"domainName" type:"string"` + + // The email address for the registrant contact at the time that we sent the + // verification email. + EmailAddress *string `locationName:"emailAddress" type:"string"` + + // True if the email address for the registrant contact has already been verified, + // and false otherwise. If the email address has already been verified, we don't + // send another confirmation email. + IsAlreadyVerified *bool `locationName:"isAlreadyVerified" type:"boolean"` +} + +// String returns the string representation +func (s ResendContactReachabilityEmailOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ResendContactReachabilityEmailOutput) GoString() string { + return s.String() +} + +// The RetrieveDomainAuthCode request includes the following element. +type RetrieveDomainAuthCodeInput struct { + _ struct{} `type:"structure"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s RetrieveDomainAuthCodeInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RetrieveDomainAuthCodeInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *RetrieveDomainAuthCodeInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "RetrieveDomainAuthCodeInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The RetrieveDomainAuthCode response includes the following element. +type RetrieveDomainAuthCodeOutput struct { + _ struct{} `type:"structure"` + + // The authorization code for the domain. + // + // Type: String + AuthCode *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s RetrieveDomainAuthCodeOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RetrieveDomainAuthCodeOutput) GoString() string { + return s.String() +} + +// Each tag includes the following elements. +type Tag struct { + _ struct{} `type:"structure"` + + // The key (name) of a tag. + // + // Type: String + // + // Default: None + // + // Valid values: A-Z, a-z, 0-9, space, ".:/=+\-@" + // + // Constraints: Each key can be 1-128 characters long. + // + // Required: Yes + Key *string `type:"string"` + + // The value of a tag. + // + // Type: String + // + // Default: None + // + // Valid values: A-Z, a-z, 0-9, space, ".:/=+\-@" + // + // Constraints: Each value can be 0-256 characters long. + // + // Required: Yes + Value *string `type:"string"` +} + +// String returns the string representation +func (s Tag) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Tag) GoString() string { + return s.String() +} + +// The TransferDomain request includes the following elements. +type TransferDomainInput struct { + _ struct{} `type:"structure"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + AdminContact *ContactDetail `type:"structure" required:"true"` + + // The authorization code for the domain. You get this value from the current + // registrar. + // + // Type: String + // + // Required: Yes + AuthCode *string `type:"string"` + + // Indicates whether the domain will be automatically renewed (true) or not + // (false). Autorenewal only takes effect after the account is charged. + // + // Type: Boolean + // + // Valid values: true | false + // + // Default: true + // + // Required: No + AutoRenew *bool `type:"boolean"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // The number of years the domain will be registered. Domains are registered + // for a minimum of one year. The maximum period depends on the top-level domain. + // + // Type: Integer + // + // Default: 1 + // + // Valid values: Integer from 1 to 10 + // + // Required: Yes + DurationInYears *int64 `min:"1" type:"integer" required:"true"` + + // Reserved for future use. + IdnLangCode *string `type:"string"` + + // Contains details for the host and glue IP addresses. + // + // Type: Complex + // + // Children: GlueIps, Name + // + // Required: No + Nameservers []*Nameserver `type:"list"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: true + // + // Valid values: true | false + // + // Required: No + PrivacyProtectAdminContact *bool `type:"boolean"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: true + // + // Valid values: true | false + // + // Required: No + PrivacyProtectRegistrantContact *bool `type:"boolean"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: true + // + // Valid values: true | false + // + // Required: No + PrivacyProtectTechContact *bool `type:"boolean"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + RegistrantContact *ContactDetail `type:"structure" required:"true"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + TechContact *ContactDetail `type:"structure" required:"true"` +} + +// String returns the string representation +func (s TransferDomainInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s TransferDomainInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *TransferDomainInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "TransferDomainInput"} + if s.AdminContact == nil { + invalidParams.Add(request.NewErrParamRequired("AdminContact")) + } + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + if s.DurationInYears == nil { + invalidParams.Add(request.NewErrParamRequired("DurationInYears")) + } + if s.DurationInYears != nil && *s.DurationInYears < 1 { + invalidParams.Add(request.NewErrParamMinValue("DurationInYears", 1)) + } + if s.RegistrantContact == nil { + invalidParams.Add(request.NewErrParamRequired("RegistrantContact")) + } + if s.TechContact == nil { + invalidParams.Add(request.NewErrParamRequired("TechContact")) + } + if s.AdminContact != nil { + if err := s.AdminContact.Validate(); err != nil { + invalidParams.AddNested("AdminContact", err.(request.ErrInvalidParams)) + } + } + if s.Nameservers != nil { + for i, v := range s.Nameservers { + if v == nil { + continue + } + if err := v.Validate(); err != nil { + invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Nameservers", i), err.(request.ErrInvalidParams)) + } + } + } + if s.RegistrantContact != nil { + if err := s.RegistrantContact.Validate(); err != nil { + invalidParams.AddNested("RegistrantContact", err.(request.ErrInvalidParams)) + } + } + if s.TechContact != nil { + if err := s.TechContact.Validate(); err != nil { + invalidParams.AddNested("TechContact", err.(request.ErrInvalidParams)) + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The TranserDomain response includes the following element. +type TransferDomainOutput struct { + _ struct{} `type:"structure"` + + // Identifier for tracking the progress of the request. To use this ID to query + // the operation status, use GetOperationDetail. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s TransferDomainOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s TransferDomainOutput) GoString() string { + return s.String() +} + +// The UpdateDomainContact request includes the following elements. +type UpdateDomainContactInput struct { + _ struct{} `type:"structure"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + AdminContact *ContactDetail `type:"structure"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + RegistrantContact *ContactDetail `type:"structure"` + + // Provides detailed contact information. + // + // Type: Complex + // + // Children: FirstName, MiddleName, LastName, ContactType, OrganizationName, + // AddressLine1, AddressLine2, City, State, CountryCode, ZipCode, PhoneNumber, + // Email, Fax, ExtraParams + // + // Required: Yes + TechContact *ContactDetail `type:"structure"` +} + +// String returns the string representation +func (s UpdateDomainContactInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateDomainContactInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *UpdateDomainContactInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "UpdateDomainContactInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + if s.AdminContact != nil { + if err := s.AdminContact.Validate(); err != nil { + invalidParams.AddNested("AdminContact", err.(request.ErrInvalidParams)) + } + } + if s.RegistrantContact != nil { + if err := s.RegistrantContact.Validate(); err != nil { + invalidParams.AddNested("RegistrantContact", err.(request.ErrInvalidParams)) + } + } + if s.TechContact != nil { + if err := s.TechContact.Validate(); err != nil { + invalidParams.AddNested("TechContact", err.(request.ErrInvalidParams)) + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The UpdateDomainContact response includes the following element. +type UpdateDomainContactOutput struct { + _ struct{} `type:"structure"` + + // Identifier for tracking the progress of the request. To use this ID to query + // the operation status, use GetOperationDetail. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s UpdateDomainContactOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateDomainContactOutput) GoString() string { + return s.String() +} + +// The UpdateDomainContactPrivacy request includes the following elements. +type UpdateDomainContactPrivacyInput struct { + _ struct{} `type:"structure"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: None + // + // Valid values: true | false + // + // Required: No + AdminPrivacy *bool `type:"boolean"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: None + // + // Valid values: true | false + // + // Required: No + RegistrantPrivacy *bool `type:"boolean"` + + // Whether you want to conceal contact information from WHOIS queries. If you + // specify true, WHOIS ("who is") queries will return contact information for + // our registrar partner, Gandi, instead of the contact information that you + // enter. + // + // Type: Boolean + // + // Default: None + // + // Valid values: true | false + // + // Required: No + TechPrivacy *bool `type:"boolean"` +} + +// String returns the string representation +func (s UpdateDomainContactPrivacyInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateDomainContactPrivacyInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *UpdateDomainContactPrivacyInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "UpdateDomainContactPrivacyInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The UpdateDomainContactPrivacy response includes the following element. +type UpdateDomainContactPrivacyOutput struct { + _ struct{} `type:"structure"` + + // Identifier for tracking the progress of the request. To use this ID to query + // the operation status, use GetOperationDetail. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s UpdateDomainContactPrivacyOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateDomainContactPrivacyOutput) GoString() string { + return s.String() +} + +// The UpdateDomainNameserver request includes the following elements. +type UpdateDomainNameserversInput struct { + _ struct{} `type:"structure"` + + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Internationalized Domain Names are not + // supported. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // The authorization key for .fi domains + FIAuthKey *string `type:"string"` + + // A list of new name servers for the domain. + // + // Type: Complex + // + // Children: Name, GlueIps + // + // Required: Yes + Nameservers []*Nameserver `type:"list" required:"true"` +} + +// String returns the string representation +func (s UpdateDomainNameserversInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateDomainNameserversInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *UpdateDomainNameserversInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "UpdateDomainNameserversInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + if s.Nameservers == nil { + invalidParams.Add(request.NewErrParamRequired("Nameservers")) + } + if s.Nameservers != nil { + for i, v := range s.Nameservers { + if v == nil { + continue + } + if err := v.Validate(); err != nil { + invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Nameservers", i), err.(request.ErrInvalidParams)) + } + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// The UpdateDomainNameservers response includes the following element. +type UpdateDomainNameserversOutput struct { + _ struct{} `type:"structure"` + + // Identifier for tracking the progress of the request. To use this ID to query + // the operation status, use GetOperationDetail. + // + // Type: String + // + // Default: None + // + // Constraints: Maximum 255 characters. + OperationId *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s UpdateDomainNameserversOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateDomainNameserversOutput) GoString() string { + return s.String() +} + +// The UpdateTagsForDomainRequest includes the following elements. +type UpdateTagsForDomainInput struct { + _ struct{} `type:"structure"` + + // The domain for which you want to add or update tags. + // + // The name of a domain. + // + // Type: String + // + // Default: None + // + // Constraints: The domain name can contain only the letters a through z, the + // numbers 0 through 9, and hyphen (-). Hyphens are allowed only when they're + // surrounded by letters, numbers, or other hyphens. You can't specify a hyphen + // at the beginning or end of a label. To specify an Internationalized Domain + // Name, you must convert the name to Punycode. + // + // Required: Yes + DomainName *string `type:"string" required:"true"` + + // A list of the tag keys and values that you want to add or update. If you + // specify a key that already exists, the corresponding value will be replaced. + // + // Type: A complex type containing a list of tags + // + // Default: None + // + // Required: No + // + // '> Each tag includes the following elements: + // + // Key + // + // The key (name) of a tag. + // + // Type: String + // + // Default: None + // + // Valid values: Unicode characters including alphanumeric, space, and ".:/=+\-@" + // + // Constraints: Each key can be 1-128 characters long. + // + // Required: Yes + // + // Value + // + // The value of a tag. + // + // Type: String + // + // Default: None + // + // Valid values: Unicode characters including alphanumeric, space, and ".:/=+\-@" + // + // Constraints: Each value can be 0-256 characters long. + // + // Required: Yes + TagsToUpdate []*Tag `type:"list"` +} + +// String returns the string representation +func (s UpdateTagsForDomainInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateTagsForDomainInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *UpdateTagsForDomainInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "UpdateTagsForDomainInput"} + if s.DomainName == nil { + invalidParams.Add(request.NewErrParamRequired("DomainName")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +type UpdateTagsForDomainOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s UpdateTagsForDomainOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateTagsForDomainOutput) GoString() string { + return s.String() +} + +// The ViewBilling request includes the following elements. +type ViewBillingInput struct { + _ struct{} `type:"structure"` + + // The end date and time for the time period for which you want a list of billing + // records. Specify the date in Unix time format. + // + // Type: Double + // + // Default: None + // + // Required: Yes + End *time.Time `type:"timestamp" timestampFormat:"unix"` + + // For an initial request for a list of billing records, omit this element. + // If the number of billing records that are associated with the current AWS + // account during the specified period is greater than the value that you specified + // for MaxItems, you can use Marker to return additional billing records. Get + // the value of NextPageMarker from the previous response, and submit another + // request that includes the value of NextPageMarker in the Marker element. + // + // Type: String + // + // Default: None + // + // Constraints: The marker must match the value of NextPageMarker that was + // returned in the previous response. + // + // Required: No + Marker *string `type:"string"` + + // The number of billing records to be returned. + // + // Type: Integer + // + // Default: 20 + // + // Constraints: A value between 1 and 100. + // + // Required: No + MaxItems *int64 `type:"integer"` + + // The beginning date and time for the time period for which you want a list + // of billing records. Specify the date in Unix time format. + // + // Type: Double + // + // Default: None + // + // Required: Yes + Start *time.Time `type:"timestamp" timestampFormat:"unix"` +} + +// String returns the string representation +func (s ViewBillingInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ViewBillingInput) GoString() string { + return s.String() +} + +// The ViewBilling response includes the following elements. +type ViewBillingOutput struct { + _ struct{} `type:"structure"` + + // A summary of billing records. + // + // Type: Complex type containing a list of billing record summaries. + // + // Children: DomainName, Operation, InvoiceId, BillDate and Price + BillingRecords []*BillingRecord `type:"list"` + + // If there are more billing records than you specified for MaxItems in the + // request, submit another request and include the value of NextPageMarker in + // the value of Marker. + // + // Type: String + // + // Parent: BillingRecords + NextPageMarker *string `type:"string"` +} + +// String returns the string representation +func (s ViewBillingOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ViewBillingOutput) GoString() string { + return s.String() +} + +const ( + // @enum ContactType + ContactTypePerson = "PERSON" + // @enum ContactType + ContactTypeCompany = "COMPANY" + // @enum ContactType + ContactTypeAssociation = "ASSOCIATION" + // @enum ContactType + ContactTypePublicBody = "PUBLIC_BODY" + // @enum ContactType + ContactTypeReseller = "RESELLER" +) + +const ( + // @enum CountryCode + CountryCodeAd = "AD" + // @enum CountryCode + CountryCodeAe = "AE" + // @enum CountryCode + CountryCodeAf = "AF" + // @enum CountryCode + CountryCodeAg = "AG" + // @enum CountryCode + CountryCodeAi = "AI" + // @enum CountryCode + CountryCodeAl = "AL" + // @enum CountryCode + CountryCodeAm = "AM" + // @enum CountryCode + CountryCodeAn = "AN" + // @enum CountryCode + CountryCodeAo = "AO" + // @enum CountryCode + CountryCodeAq = "AQ" + // @enum CountryCode + CountryCodeAr = "AR" + // @enum CountryCode + CountryCodeAs = "AS" + // @enum CountryCode + CountryCodeAt = "AT" + // @enum CountryCode + CountryCodeAu = "AU" + // @enum CountryCode + CountryCodeAw = "AW" + // @enum CountryCode + CountryCodeAz = "AZ" + // @enum CountryCode + CountryCodeBa = "BA" + // @enum CountryCode + CountryCodeBb = "BB" + // @enum CountryCode + CountryCodeBd = "BD" + // @enum CountryCode + CountryCodeBe = "BE" + // @enum CountryCode + CountryCodeBf = "BF" + // @enum CountryCode + CountryCodeBg = "BG" + // @enum CountryCode + CountryCodeBh = "BH" + // @enum CountryCode + CountryCodeBi = "BI" + // @enum CountryCode + CountryCodeBj = "BJ" + // @enum CountryCode + CountryCodeBl = "BL" + // @enum CountryCode + CountryCodeBm = "BM" + // @enum CountryCode + CountryCodeBn = "BN" + // @enum CountryCode + CountryCodeBo = "BO" + // @enum CountryCode + CountryCodeBr = "BR" + // @enum CountryCode + CountryCodeBs = "BS" + // @enum CountryCode + CountryCodeBt = "BT" + // @enum CountryCode + CountryCodeBw = "BW" + // @enum CountryCode + CountryCodeBy = "BY" + // @enum CountryCode + CountryCodeBz = "BZ" + // @enum CountryCode + CountryCodeCa = "CA" + // @enum CountryCode + CountryCodeCc = "CC" + // @enum CountryCode + CountryCodeCd = "CD" + // @enum CountryCode + CountryCodeCf = "CF" + // @enum CountryCode + CountryCodeCg = "CG" + // @enum CountryCode + CountryCodeCh = "CH" + // @enum CountryCode + CountryCodeCi = "CI" + // @enum CountryCode + CountryCodeCk = "CK" + // @enum CountryCode + CountryCodeCl = "CL" + // @enum CountryCode + CountryCodeCm = "CM" + // @enum CountryCode + CountryCodeCn = "CN" + // @enum CountryCode + CountryCodeCo = "CO" + // @enum CountryCode + CountryCodeCr = "CR" + // @enum CountryCode + CountryCodeCu = "CU" + // @enum CountryCode + CountryCodeCv = "CV" + // @enum CountryCode + CountryCodeCx = "CX" + // @enum CountryCode + CountryCodeCy = "CY" + // @enum CountryCode + CountryCodeCz = "CZ" + // @enum CountryCode + CountryCodeDe = "DE" + // @enum CountryCode + CountryCodeDj = "DJ" + // @enum CountryCode + CountryCodeDk = "DK" + // @enum CountryCode + CountryCodeDm = "DM" + // @enum CountryCode + CountryCodeDo = "DO" + // @enum CountryCode + CountryCodeDz = "DZ" + // @enum CountryCode + CountryCodeEc = "EC" + // @enum CountryCode + CountryCodeEe = "EE" + // @enum CountryCode + CountryCodeEg = "EG" + // @enum CountryCode + CountryCodeEr = "ER" + // @enum CountryCode + CountryCodeEs = "ES" + // @enum CountryCode + CountryCodeEt = "ET" + // @enum CountryCode + CountryCodeFi = "FI" + // @enum CountryCode + CountryCodeFj = "FJ" + // @enum CountryCode + CountryCodeFk = "FK" + // @enum CountryCode + CountryCodeFm = "FM" + // @enum CountryCode + CountryCodeFo = "FO" + // @enum CountryCode + CountryCodeFr = "FR" + // @enum CountryCode + CountryCodeGa = "GA" + // @enum CountryCode + CountryCodeGb = "GB" + // @enum CountryCode + CountryCodeGd = "GD" + // @enum CountryCode + CountryCodeGe = "GE" + // @enum CountryCode + CountryCodeGh = "GH" + // @enum CountryCode + CountryCodeGi = "GI" + // @enum CountryCode + CountryCodeGl = "GL" + // @enum CountryCode + CountryCodeGm = "GM" + // @enum CountryCode + CountryCodeGn = "GN" + // @enum CountryCode + CountryCodeGq = "GQ" + // @enum CountryCode + CountryCodeGr = "GR" + // @enum CountryCode + CountryCodeGt = "GT" + // @enum CountryCode + CountryCodeGu = "GU" + // @enum CountryCode + CountryCodeGw = "GW" + // @enum CountryCode + CountryCodeGy = "GY" + // @enum CountryCode + CountryCodeHk = "HK" + // @enum CountryCode + CountryCodeHn = "HN" + // @enum CountryCode + CountryCodeHr = "HR" + // @enum CountryCode + CountryCodeHt = "HT" + // @enum CountryCode + CountryCodeHu = "HU" + // @enum CountryCode + CountryCodeId = "ID" + // @enum CountryCode + CountryCodeIe = "IE" + // @enum CountryCode + CountryCodeIl = "IL" + // @enum CountryCode + CountryCodeIm = "IM" + // @enum CountryCode + CountryCodeIn = "IN" + // @enum CountryCode + CountryCodeIq = "IQ" + // @enum CountryCode + CountryCodeIr = "IR" + // @enum CountryCode + CountryCodeIs = "IS" + // @enum CountryCode + CountryCodeIt = "IT" + // @enum CountryCode + CountryCodeJm = "JM" + // @enum CountryCode + CountryCodeJo = "JO" + // @enum CountryCode + CountryCodeJp = "JP" + // @enum CountryCode + CountryCodeKe = "KE" + // @enum CountryCode + CountryCodeKg = "KG" + // @enum CountryCode + CountryCodeKh = "KH" + // @enum CountryCode + CountryCodeKi = "KI" + // @enum CountryCode + CountryCodeKm = "KM" + // @enum CountryCode + CountryCodeKn = "KN" + // @enum CountryCode + CountryCodeKp = "KP" + // @enum CountryCode + CountryCodeKr = "KR" + // @enum CountryCode + CountryCodeKw = "KW" + // @enum CountryCode + CountryCodeKy = "KY" + // @enum CountryCode + CountryCodeKz = "KZ" + // @enum CountryCode + CountryCodeLa = "LA" + // @enum CountryCode + CountryCodeLb = "LB" + // @enum CountryCode + CountryCodeLc = "LC" + // @enum CountryCode + CountryCodeLi = "LI" + // @enum CountryCode + CountryCodeLk = "LK" + // @enum CountryCode + CountryCodeLr = "LR" + // @enum CountryCode + CountryCodeLs = "LS" + // @enum CountryCode + CountryCodeLt = "LT" + // @enum CountryCode + CountryCodeLu = "LU" + // @enum CountryCode + CountryCodeLv = "LV" + // @enum CountryCode + CountryCodeLy = "LY" + // @enum CountryCode + CountryCodeMa = "MA" + // @enum CountryCode + CountryCodeMc = "MC" + // @enum CountryCode + CountryCodeMd = "MD" + // @enum CountryCode + CountryCodeMe = "ME" + // @enum CountryCode + CountryCodeMf = "MF" + // @enum CountryCode + CountryCodeMg = "MG" + // @enum CountryCode + CountryCodeMh = "MH" + // @enum CountryCode + CountryCodeMk = "MK" + // @enum CountryCode + CountryCodeMl = "ML" + // @enum CountryCode + CountryCodeMm = "MM" + // @enum CountryCode + CountryCodeMn = "MN" + // @enum CountryCode + CountryCodeMo = "MO" + // @enum CountryCode + CountryCodeMp = "MP" + // @enum CountryCode + CountryCodeMr = "MR" + // @enum CountryCode + CountryCodeMs = "MS" + // @enum CountryCode + CountryCodeMt = "MT" + // @enum CountryCode + CountryCodeMu = "MU" + // @enum CountryCode + CountryCodeMv = "MV" + // @enum CountryCode + CountryCodeMw = "MW" + // @enum CountryCode + CountryCodeMx = "MX" + // @enum CountryCode + CountryCodeMy = "MY" + // @enum CountryCode + CountryCodeMz = "MZ" + // @enum CountryCode + CountryCodeNa = "NA" + // @enum CountryCode + CountryCodeNc = "NC" + // @enum CountryCode + CountryCodeNe = "NE" + // @enum CountryCode + CountryCodeNg = "NG" + // @enum CountryCode + CountryCodeNi = "NI" + // @enum CountryCode + CountryCodeNl = "NL" + // @enum CountryCode + CountryCodeNo = "NO" + // @enum CountryCode + CountryCodeNp = "NP" + // @enum CountryCode + CountryCodeNr = "NR" + // @enum CountryCode + CountryCodeNu = "NU" + // @enum CountryCode + CountryCodeNz = "NZ" + // @enum CountryCode + CountryCodeOm = "OM" + // @enum CountryCode + CountryCodePa = "PA" + // @enum CountryCode + CountryCodePe = "PE" + // @enum CountryCode + CountryCodePf = "PF" + // @enum CountryCode + CountryCodePg = "PG" + // @enum CountryCode + CountryCodePh = "PH" + // @enum CountryCode + CountryCodePk = "PK" + // @enum CountryCode + CountryCodePl = "PL" + // @enum CountryCode + CountryCodePm = "PM" + // @enum CountryCode + CountryCodePn = "PN" + // @enum CountryCode + CountryCodePr = "PR" + // @enum CountryCode + CountryCodePt = "PT" + // @enum CountryCode + CountryCodePw = "PW" + // @enum CountryCode + CountryCodePy = "PY" + // @enum CountryCode + CountryCodeQa = "QA" + // @enum CountryCode + CountryCodeRo = "RO" + // @enum CountryCode + CountryCodeRs = "RS" + // @enum CountryCode + CountryCodeRu = "RU" + // @enum CountryCode + CountryCodeRw = "RW" + // @enum CountryCode + CountryCodeSa = "SA" + // @enum CountryCode + CountryCodeSb = "SB" + // @enum CountryCode + CountryCodeSc = "SC" + // @enum CountryCode + CountryCodeSd = "SD" + // @enum CountryCode + CountryCodeSe = "SE" + // @enum CountryCode + CountryCodeSg = "SG" + // @enum CountryCode + CountryCodeSh = "SH" + // @enum CountryCode + CountryCodeSi = "SI" + // @enum CountryCode + CountryCodeSk = "SK" + // @enum CountryCode + CountryCodeSl = "SL" + // @enum CountryCode + CountryCodeSm = "SM" + // @enum CountryCode + CountryCodeSn = "SN" + // @enum CountryCode + CountryCodeSo = "SO" + // @enum CountryCode + CountryCodeSr = "SR" + // @enum CountryCode + CountryCodeSt = "ST" + // @enum CountryCode + CountryCodeSv = "SV" + // @enum CountryCode + CountryCodeSy = "SY" + // @enum CountryCode + CountryCodeSz = "SZ" + // @enum CountryCode + CountryCodeTc = "TC" + // @enum CountryCode + CountryCodeTd = "TD" + // @enum CountryCode + CountryCodeTg = "TG" + // @enum CountryCode + CountryCodeTh = "TH" + // @enum CountryCode + CountryCodeTj = "TJ" + // @enum CountryCode + CountryCodeTk = "TK" + // @enum CountryCode + CountryCodeTl = "TL" + // @enum CountryCode + CountryCodeTm = "TM" + // @enum CountryCode + CountryCodeTn = "TN" + // @enum CountryCode + CountryCodeTo = "TO" + // @enum CountryCode + CountryCodeTr = "TR" + // @enum CountryCode + CountryCodeTt = "TT" + // @enum CountryCode + CountryCodeTv = "TV" + // @enum CountryCode + CountryCodeTw = "TW" + // @enum CountryCode + CountryCodeTz = "TZ" + // @enum CountryCode + CountryCodeUa = "UA" + // @enum CountryCode + CountryCodeUg = "UG" + // @enum CountryCode + CountryCodeUs = "US" + // @enum CountryCode + CountryCodeUy = "UY" + // @enum CountryCode + CountryCodeUz = "UZ" + // @enum CountryCode + CountryCodeVa = "VA" + // @enum CountryCode + CountryCodeVc = "VC" + // @enum CountryCode + CountryCodeVe = "VE" + // @enum CountryCode + CountryCodeVg = "VG" + // @enum CountryCode + CountryCodeVi = "VI" + // @enum CountryCode + CountryCodeVn = "VN" + // @enum CountryCode + CountryCodeVu = "VU" + // @enum CountryCode + CountryCodeWf = "WF" + // @enum CountryCode + CountryCodeWs = "WS" + // @enum CountryCode + CountryCodeYe = "YE" + // @enum CountryCode + CountryCodeYt = "YT" + // @enum CountryCode + CountryCodeZa = "ZA" + // @enum CountryCode + CountryCodeZm = "ZM" + // @enum CountryCode + CountryCodeZw = "ZW" +) + +const ( + // @enum DomainAvailability + DomainAvailabilityAvailable = "AVAILABLE" + // @enum DomainAvailability + DomainAvailabilityAvailableReserved = "AVAILABLE_RESERVED" + // @enum DomainAvailability + DomainAvailabilityAvailablePreorder = "AVAILABLE_PREORDER" + // @enum DomainAvailability + DomainAvailabilityUnavailable = "UNAVAILABLE" + // @enum DomainAvailability + DomainAvailabilityUnavailablePremium = "UNAVAILABLE_PREMIUM" + // @enum DomainAvailability + DomainAvailabilityUnavailableRestricted = "UNAVAILABLE_RESTRICTED" + // @enum DomainAvailability + DomainAvailabilityReserved = "RESERVED" + // @enum DomainAvailability + DomainAvailabilityDontKnow = "DONT_KNOW" +) + +const ( + // @enum ExtraParamName + ExtraParamNameDunsNumber = "DUNS_NUMBER" + // @enum ExtraParamName + ExtraParamNameBrandNumber = "BRAND_NUMBER" + // @enum ExtraParamName + ExtraParamNameBirthDepartment = "BIRTH_DEPARTMENT" + // @enum ExtraParamName + ExtraParamNameBirthDateInYyyyMmDd = "BIRTH_DATE_IN_YYYY_MM_DD" + // @enum ExtraParamName + ExtraParamNameBirthCountry = "BIRTH_COUNTRY" + // @enum ExtraParamName + ExtraParamNameBirthCity = "BIRTH_CITY" + // @enum ExtraParamName + ExtraParamNameDocumentNumber = "DOCUMENT_NUMBER" + // @enum ExtraParamName + ExtraParamNameAuIdNumber = "AU_ID_NUMBER" + // @enum ExtraParamName + ExtraParamNameAuIdType = "AU_ID_TYPE" + // @enum ExtraParamName + ExtraParamNameCaLegalType = "CA_LEGAL_TYPE" + // @enum ExtraParamName + ExtraParamNameCaBusinessEntityType = "CA_BUSINESS_ENTITY_TYPE" + // @enum ExtraParamName + ExtraParamNameEsIdentification = "ES_IDENTIFICATION" + // @enum ExtraParamName + ExtraParamNameEsIdentificationType = "ES_IDENTIFICATION_TYPE" + // @enum ExtraParamName + ExtraParamNameEsLegalForm = "ES_LEGAL_FORM" + // @enum ExtraParamName + ExtraParamNameFiBusinessNumber = "FI_BUSINESS_NUMBER" + // @enum ExtraParamName + ExtraParamNameFiIdNumber = "FI_ID_NUMBER" + // @enum ExtraParamName + ExtraParamNameItPin = "IT_PIN" + // @enum ExtraParamName + ExtraParamNameRuPassportData = "RU_PASSPORT_DATA" + // @enum ExtraParamName + ExtraParamNameSeIdNumber = "SE_ID_NUMBER" + // @enum ExtraParamName + ExtraParamNameSgIdNumber = "SG_ID_NUMBER" + // @enum ExtraParamName + ExtraParamNameVatNumber = "VAT_NUMBER" +) + +const ( + // @enum OperationStatus + OperationStatusSubmitted = "SUBMITTED" + // @enum OperationStatus + OperationStatusInProgress = "IN_PROGRESS" + // @enum OperationStatus + OperationStatusError = "ERROR" + // @enum OperationStatus + OperationStatusSuccessful = "SUCCESSFUL" + // @enum OperationStatus + OperationStatusFailed = "FAILED" +) + +const ( + // @enum OperationType + OperationTypeRegisterDomain = "REGISTER_DOMAIN" + // @enum OperationType + OperationTypeDeleteDomain = "DELETE_DOMAIN" + // @enum OperationType + OperationTypeTransferInDomain = "TRANSFER_IN_DOMAIN" + // @enum OperationType + OperationTypeUpdateDomainContact = "UPDATE_DOMAIN_CONTACT" + // @enum OperationType + OperationTypeUpdateNameserver = "UPDATE_NAMESERVER" + // @enum OperationType + OperationTypeChangePrivacyProtection = "CHANGE_PRIVACY_PROTECTION" + // @enum OperationType + OperationTypeDomainLock = "DOMAIN_LOCK" +) + +const ( + // @enum ReachabilityStatus + ReachabilityStatusPending = "PENDING" + // @enum ReachabilityStatus + ReachabilityStatusDone = "DONE" + // @enum ReachabilityStatus + ReachabilityStatusExpired = "EXPIRED" +) diff --git a/vendor/github.com/aws/aws-sdk-go/service/route53domains/service.go b/vendor/github.com/aws/aws-sdk-go/service/route53domains/service.go new file mode 100644 index 000000000..f119641ea --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/route53domains/service.go @@ -0,0 +1,88 @@ +// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. + +package route53domains + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/client" + "github.com/aws/aws-sdk-go/aws/client/metadata" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/aws/signer/v4" + "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" +) + +// Route53Domains is a client for Amazon Route 53 Domains. +//The service client's operations are safe to be used concurrently. +// It is not safe to mutate any of the client's properties though. +type Route53Domains struct { + *client.Client +} + +// Used for custom client initialization logic +var initClient func(*client.Client) + +// Used for custom request initialization logic +var initRequest func(*request.Request) + +// A ServiceName is the name of the service the client will make API calls to. +const ServiceName = "route53domains" + +// New creates a new instance of the Route53Domains client with a session. +// If additional configuration is needed for the client instance use the optional +// aws.Config parameter to add your extra config. +// +// Example: +// // Create a Route53Domains client from just a session. +// svc := route53domains.New(mySession) +// +// // Create a Route53Domains client with additional configuration +// svc := route53domains.New(mySession, aws.NewConfig().WithRegion("us-west-2")) +func New(p client.ConfigProvider, cfgs ...*aws.Config) *Route53Domains { + c := p.ClientConfig(ServiceName, cfgs...) + return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion) +} + +// newClient creates, initializes and returns a new service client instance. +func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string) *Route53Domains { + svc := &Route53Domains{ + Client: client.New( + cfg, + metadata.ClientInfo{ + ServiceName: ServiceName, + SigningRegion: signingRegion, + Endpoint: endpoint, + APIVersion: "2014-05-15", + JSONVersion: "1.1", + TargetPrefix: "Route53Domains_v20140515", + }, + handlers, + ), + } + + // Handlers + svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) + svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) + svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) + svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) + svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) + + // Run custom client initialization if present + if initClient != nil { + initClient(svc.Client) + } + + return svc +} + +// newRequest creates a new request for a Route53Domains operation and runs any +// custom request initialization. +func (c *Route53Domains) newRequest(op *request.Operation, params, data interface{}) *request.Request { + req := c.NewRequest(op, params, data) + + // Run custom request initialization if present + if initRequest != nil { + initRequest(req) + } + + return req +} diff --git a/vendor/vendor.json b/vendor/vendor.json index a1f07eab3..5a4c3a549 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -133,6 +133,18 @@ "revision": "f80e7d0182a463dff0c0da6bbed57f21369d4346", "revisionTime": "2016-08-11T16:24:59Z" }, + { + "checksumSHA1": "O6hcK24yI6w7FA+g4Pbr+eQ7pys=", + "path": "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil", + "revision": "aafdacd0d6e625a7a2782bef5f9942d6fc4c9f30", + "revisionTime": "2017-07-14T21:00:53Z" + }, + { + "checksumSHA1": "R00RL5jJXRYq1iiK1+PGvMfvXyM=", + "path": "github.com/aws/aws-sdk-go/private/protocol/jsonrpc", + "revision": "aafdacd0d6e625a7a2782bef5f9942d6fc4c9f30", + "revisionTime": "2017-07-14T21:00:53Z" + }, { "checksumSHA1": "isoix7lTx4qIq2zI2xFADtti5SI=", "path": "github.com/aws/aws-sdk-go/private/protocol/query", @@ -181,6 +193,12 @@ "revision": "f80e7d0182a463dff0c0da6bbed57f21369d4346", "revisionTime": "2016-08-11T16:24:59Z" }, + { + "checksumSHA1": "qS3eZZfhdDM6haTZp7OeyhMDlV8=", + "path": "github.com/aws/aws-sdk-go/service/route53domains", + "revision": "f80e7d0182a463dff0c0da6bbed57f21369d4346", + "revisionTime": "2016-08-11T16:24:59Z" + }, { "checksumSHA1": "nH/itbdeFHpl4ysegdtgww9bFSA=", "path": "github.com/aws/aws-sdk-go/service/sts",