1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package route53domains 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/route53domains/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAcceptDomainTransferFromAnotherAwsAccount struct { 14} 15 16func (*validateOpAcceptDomainTransferFromAnotherAwsAccount) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAcceptDomainTransferFromAnotherAwsAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 21 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 22) { 23 input, ok := in.Parameters.(*AcceptDomainTransferFromAnotherAwsAccountInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAcceptDomainTransferFromAnotherAwsAccountInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCancelDomainTransferToAnotherAwsAccount struct { 34} 35 36func (*validateOpCancelDomainTransferToAnotherAwsAccount) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCancelDomainTransferToAnotherAwsAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 41 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 42) { 43 input, ok := in.Parameters.(*CancelDomainTransferToAnotherAwsAccountInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCancelDomainTransferToAnotherAwsAccountInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCheckDomainAvailability struct { 54} 55 56func (*validateOpCheckDomainAvailability) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCheckDomainAvailability) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 61 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 62) { 63 input, ok := in.Parameters.(*CheckDomainAvailabilityInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCheckDomainAvailabilityInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCheckDomainTransferability struct { 74} 75 76func (*validateOpCheckDomainTransferability) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCheckDomainTransferability) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 81 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 82) { 83 input, ok := in.Parameters.(*CheckDomainTransferabilityInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCheckDomainTransferabilityInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeleteTagsForDomain struct { 94} 95 96func (*validateOpDeleteTagsForDomain) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeleteTagsForDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 102) { 103 input, ok := in.Parameters.(*DeleteTagsForDomainInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeleteTagsForDomainInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDisableDomainAutoRenew struct { 114} 115 116func (*validateOpDisableDomainAutoRenew) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDisableDomainAutoRenew) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 122) { 123 input, ok := in.Parameters.(*DisableDomainAutoRenewInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDisableDomainAutoRenewInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDisableDomainTransferLock struct { 134} 135 136func (*validateOpDisableDomainTransferLock) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDisableDomainTransferLock) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 142) { 143 input, ok := in.Parameters.(*DisableDomainTransferLockInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDisableDomainTransferLockInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpEnableDomainAutoRenew struct { 154} 155 156func (*validateOpEnableDomainAutoRenew) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpEnableDomainAutoRenew) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 162) { 163 input, ok := in.Parameters.(*EnableDomainAutoRenewInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpEnableDomainAutoRenewInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpEnableDomainTransferLock struct { 174} 175 176func (*validateOpEnableDomainTransferLock) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpEnableDomainTransferLock) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 182) { 183 input, ok := in.Parameters.(*EnableDomainTransferLockInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpEnableDomainTransferLockInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpGetDomainDetail struct { 194} 195 196func (*validateOpGetDomainDetail) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpGetDomainDetail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 202) { 203 input, ok := in.Parameters.(*GetDomainDetailInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpGetDomainDetailInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpGetDomainSuggestions struct { 214} 215 216func (*validateOpGetDomainSuggestions) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpGetDomainSuggestions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 222) { 223 input, ok := in.Parameters.(*GetDomainSuggestionsInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpGetDomainSuggestionsInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpGetOperationDetail struct { 234} 235 236func (*validateOpGetOperationDetail) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpGetOperationDetail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 242) { 243 input, ok := in.Parameters.(*GetOperationDetailInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpGetOperationDetailInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpListTagsForDomain struct { 254} 255 256func (*validateOpListTagsForDomain) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpListTagsForDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 262) { 263 input, ok := in.Parameters.(*ListTagsForDomainInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpListTagsForDomainInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpRegisterDomain struct { 274} 275 276func (*validateOpRegisterDomain) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpRegisterDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 282) { 283 input, ok := in.Parameters.(*RegisterDomainInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpRegisterDomainInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpRejectDomainTransferFromAnotherAwsAccount struct { 294} 295 296func (*validateOpRejectDomainTransferFromAnotherAwsAccount) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpRejectDomainTransferFromAnotherAwsAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 302) { 303 input, ok := in.Parameters.(*RejectDomainTransferFromAnotherAwsAccountInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpRejectDomainTransferFromAnotherAwsAccountInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpRenewDomain struct { 314} 315 316func (*validateOpRenewDomain) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpRenewDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 322) { 323 input, ok := in.Parameters.(*RenewDomainInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpRenewDomainInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpRetrieveDomainAuthCode struct { 334} 335 336func (*validateOpRetrieveDomainAuthCode) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpRetrieveDomainAuthCode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 342) { 343 input, ok := in.Parameters.(*RetrieveDomainAuthCodeInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpRetrieveDomainAuthCodeInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpTransferDomain struct { 354} 355 356func (*validateOpTransferDomain) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpTransferDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 361 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 362) { 363 input, ok := in.Parameters.(*TransferDomainInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpTransferDomainInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpTransferDomainToAnotherAwsAccount struct { 374} 375 376func (*validateOpTransferDomainToAnotherAwsAccount) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpTransferDomainToAnotherAwsAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 382) { 383 input, ok := in.Parameters.(*TransferDomainToAnotherAwsAccountInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpTransferDomainToAnotherAwsAccountInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpUpdateDomainContact struct { 394} 395 396func (*validateOpUpdateDomainContact) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpUpdateDomainContact) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 402) { 403 input, ok := in.Parameters.(*UpdateDomainContactInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpUpdateDomainContactInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpUpdateDomainContactPrivacy struct { 414} 415 416func (*validateOpUpdateDomainContactPrivacy) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpUpdateDomainContactPrivacy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 422) { 423 input, ok := in.Parameters.(*UpdateDomainContactPrivacyInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpUpdateDomainContactPrivacyInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpUpdateDomainNameservers struct { 434} 435 436func (*validateOpUpdateDomainNameservers) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpUpdateDomainNameservers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 442) { 443 input, ok := in.Parameters.(*UpdateDomainNameserversInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpUpdateDomainNameserversInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpUpdateTagsForDomain struct { 454} 455 456func (*validateOpUpdateTagsForDomain) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpUpdateTagsForDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 462) { 463 input, ok := in.Parameters.(*UpdateTagsForDomainInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpUpdateTagsForDomainInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473func addOpAcceptDomainTransferFromAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error { 474 return stack.Initialize.Add(&validateOpAcceptDomainTransferFromAnotherAwsAccount{}, middleware.After) 475} 476 477func addOpCancelDomainTransferToAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error { 478 return stack.Initialize.Add(&validateOpCancelDomainTransferToAnotherAwsAccount{}, middleware.After) 479} 480 481func addOpCheckDomainAvailabilityValidationMiddleware(stack *middleware.Stack) error { 482 return stack.Initialize.Add(&validateOpCheckDomainAvailability{}, middleware.After) 483} 484 485func addOpCheckDomainTransferabilityValidationMiddleware(stack *middleware.Stack) error { 486 return stack.Initialize.Add(&validateOpCheckDomainTransferability{}, middleware.After) 487} 488 489func addOpDeleteTagsForDomainValidationMiddleware(stack *middleware.Stack) error { 490 return stack.Initialize.Add(&validateOpDeleteTagsForDomain{}, middleware.After) 491} 492 493func addOpDisableDomainAutoRenewValidationMiddleware(stack *middleware.Stack) error { 494 return stack.Initialize.Add(&validateOpDisableDomainAutoRenew{}, middleware.After) 495} 496 497func addOpDisableDomainTransferLockValidationMiddleware(stack *middleware.Stack) error { 498 return stack.Initialize.Add(&validateOpDisableDomainTransferLock{}, middleware.After) 499} 500 501func addOpEnableDomainAutoRenewValidationMiddleware(stack *middleware.Stack) error { 502 return stack.Initialize.Add(&validateOpEnableDomainAutoRenew{}, middleware.After) 503} 504 505func addOpEnableDomainTransferLockValidationMiddleware(stack *middleware.Stack) error { 506 return stack.Initialize.Add(&validateOpEnableDomainTransferLock{}, middleware.After) 507} 508 509func addOpGetDomainDetailValidationMiddleware(stack *middleware.Stack) error { 510 return stack.Initialize.Add(&validateOpGetDomainDetail{}, middleware.After) 511} 512 513func addOpGetDomainSuggestionsValidationMiddleware(stack *middleware.Stack) error { 514 return stack.Initialize.Add(&validateOpGetDomainSuggestions{}, middleware.After) 515} 516 517func addOpGetOperationDetailValidationMiddleware(stack *middleware.Stack) error { 518 return stack.Initialize.Add(&validateOpGetOperationDetail{}, middleware.After) 519} 520 521func addOpListTagsForDomainValidationMiddleware(stack *middleware.Stack) error { 522 return stack.Initialize.Add(&validateOpListTagsForDomain{}, middleware.After) 523} 524 525func addOpRegisterDomainValidationMiddleware(stack *middleware.Stack) error { 526 return stack.Initialize.Add(&validateOpRegisterDomain{}, middleware.After) 527} 528 529func addOpRejectDomainTransferFromAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error { 530 return stack.Initialize.Add(&validateOpRejectDomainTransferFromAnotherAwsAccount{}, middleware.After) 531} 532 533func addOpRenewDomainValidationMiddleware(stack *middleware.Stack) error { 534 return stack.Initialize.Add(&validateOpRenewDomain{}, middleware.After) 535} 536 537func addOpRetrieveDomainAuthCodeValidationMiddleware(stack *middleware.Stack) error { 538 return stack.Initialize.Add(&validateOpRetrieveDomainAuthCode{}, middleware.After) 539} 540 541func addOpTransferDomainValidationMiddleware(stack *middleware.Stack) error { 542 return stack.Initialize.Add(&validateOpTransferDomain{}, middleware.After) 543} 544 545func addOpTransferDomainToAnotherAwsAccountValidationMiddleware(stack *middleware.Stack) error { 546 return stack.Initialize.Add(&validateOpTransferDomainToAnotherAwsAccount{}, middleware.After) 547} 548 549func addOpUpdateDomainContactValidationMiddleware(stack *middleware.Stack) error { 550 return stack.Initialize.Add(&validateOpUpdateDomainContact{}, middleware.After) 551} 552 553func addOpUpdateDomainContactPrivacyValidationMiddleware(stack *middleware.Stack) error { 554 return stack.Initialize.Add(&validateOpUpdateDomainContactPrivacy{}, middleware.After) 555} 556 557func addOpUpdateDomainNameserversValidationMiddleware(stack *middleware.Stack) error { 558 return stack.Initialize.Add(&validateOpUpdateDomainNameservers{}, middleware.After) 559} 560 561func addOpUpdateTagsForDomainValidationMiddleware(stack *middleware.Stack) error { 562 return stack.Initialize.Add(&validateOpUpdateTagsForDomain{}, middleware.After) 563} 564 565func validateContactDetail(v *types.ContactDetail) error { 566 if v == nil { 567 return nil 568 } 569 invalidParams := smithy.InvalidParamsError{Context: "ContactDetail"} 570 if v.ExtraParams != nil { 571 if err := validateExtraParamList(v.ExtraParams); err != nil { 572 invalidParams.AddNested("ExtraParams", err.(smithy.InvalidParamsError)) 573 } 574 } 575 if invalidParams.Len() > 0 { 576 return invalidParams 577 } else { 578 return nil 579 } 580} 581 582func validateExtraParam(v *types.ExtraParam) error { 583 if v == nil { 584 return nil 585 } 586 invalidParams := smithy.InvalidParamsError{Context: "ExtraParam"} 587 if len(v.Name) == 0 { 588 invalidParams.Add(smithy.NewErrParamRequired("Name")) 589 } 590 if v.Value == nil { 591 invalidParams.Add(smithy.NewErrParamRequired("Value")) 592 } 593 if invalidParams.Len() > 0 { 594 return invalidParams 595 } else { 596 return nil 597 } 598} 599 600func validateExtraParamList(v []types.ExtraParam) error { 601 if v == nil { 602 return nil 603 } 604 invalidParams := smithy.InvalidParamsError{Context: "ExtraParamList"} 605 for i := range v { 606 if err := validateExtraParam(&v[i]); err != nil { 607 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 608 } 609 } 610 if invalidParams.Len() > 0 { 611 return invalidParams 612 } else { 613 return nil 614 } 615} 616 617func validateNameserver(v *types.Nameserver) error { 618 if v == nil { 619 return nil 620 } 621 invalidParams := smithy.InvalidParamsError{Context: "Nameserver"} 622 if v.Name == nil { 623 invalidParams.Add(smithy.NewErrParamRequired("Name")) 624 } 625 if invalidParams.Len() > 0 { 626 return invalidParams 627 } else { 628 return nil 629 } 630} 631 632func validateNameserverList(v []types.Nameserver) error { 633 if v == nil { 634 return nil 635 } 636 invalidParams := smithy.InvalidParamsError{Context: "NameserverList"} 637 for i := range v { 638 if err := validateNameserver(&v[i]); err != nil { 639 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 640 } 641 } 642 if invalidParams.Len() > 0 { 643 return invalidParams 644 } else { 645 return nil 646 } 647} 648 649func validateOpAcceptDomainTransferFromAnotherAwsAccountInput(v *AcceptDomainTransferFromAnotherAwsAccountInput) error { 650 if v == nil { 651 return nil 652 } 653 invalidParams := smithy.InvalidParamsError{Context: "AcceptDomainTransferFromAnotherAwsAccountInput"} 654 if v.DomainName == nil { 655 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 656 } 657 if v.Password == nil { 658 invalidParams.Add(smithy.NewErrParamRequired("Password")) 659 } 660 if invalidParams.Len() > 0 { 661 return invalidParams 662 } else { 663 return nil 664 } 665} 666 667func validateOpCancelDomainTransferToAnotherAwsAccountInput(v *CancelDomainTransferToAnotherAwsAccountInput) error { 668 if v == nil { 669 return nil 670 } 671 invalidParams := smithy.InvalidParamsError{Context: "CancelDomainTransferToAnotherAwsAccountInput"} 672 if v.DomainName == nil { 673 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 674 } 675 if invalidParams.Len() > 0 { 676 return invalidParams 677 } else { 678 return nil 679 } 680} 681 682func validateOpCheckDomainAvailabilityInput(v *CheckDomainAvailabilityInput) error { 683 if v == nil { 684 return nil 685 } 686 invalidParams := smithy.InvalidParamsError{Context: "CheckDomainAvailabilityInput"} 687 if v.DomainName == nil { 688 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 689 } 690 if invalidParams.Len() > 0 { 691 return invalidParams 692 } else { 693 return nil 694 } 695} 696 697func validateOpCheckDomainTransferabilityInput(v *CheckDomainTransferabilityInput) error { 698 if v == nil { 699 return nil 700 } 701 invalidParams := smithy.InvalidParamsError{Context: "CheckDomainTransferabilityInput"} 702 if v.DomainName == nil { 703 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 704 } 705 if invalidParams.Len() > 0 { 706 return invalidParams 707 } else { 708 return nil 709 } 710} 711 712func validateOpDeleteTagsForDomainInput(v *DeleteTagsForDomainInput) error { 713 if v == nil { 714 return nil 715 } 716 invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsForDomainInput"} 717 if v.DomainName == nil { 718 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 719 } 720 if v.TagsToDelete == nil { 721 invalidParams.Add(smithy.NewErrParamRequired("TagsToDelete")) 722 } 723 if invalidParams.Len() > 0 { 724 return invalidParams 725 } else { 726 return nil 727 } 728} 729 730func validateOpDisableDomainAutoRenewInput(v *DisableDomainAutoRenewInput) error { 731 if v == nil { 732 return nil 733 } 734 invalidParams := smithy.InvalidParamsError{Context: "DisableDomainAutoRenewInput"} 735 if v.DomainName == nil { 736 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 737 } 738 if invalidParams.Len() > 0 { 739 return invalidParams 740 } else { 741 return nil 742 } 743} 744 745func validateOpDisableDomainTransferLockInput(v *DisableDomainTransferLockInput) error { 746 if v == nil { 747 return nil 748 } 749 invalidParams := smithy.InvalidParamsError{Context: "DisableDomainTransferLockInput"} 750 if v.DomainName == nil { 751 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 752 } 753 if invalidParams.Len() > 0 { 754 return invalidParams 755 } else { 756 return nil 757 } 758} 759 760func validateOpEnableDomainAutoRenewInput(v *EnableDomainAutoRenewInput) error { 761 if v == nil { 762 return nil 763 } 764 invalidParams := smithy.InvalidParamsError{Context: "EnableDomainAutoRenewInput"} 765 if v.DomainName == nil { 766 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 767 } 768 if invalidParams.Len() > 0 { 769 return invalidParams 770 } else { 771 return nil 772 } 773} 774 775func validateOpEnableDomainTransferLockInput(v *EnableDomainTransferLockInput) error { 776 if v == nil { 777 return nil 778 } 779 invalidParams := smithy.InvalidParamsError{Context: "EnableDomainTransferLockInput"} 780 if v.DomainName == nil { 781 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 782 } 783 if invalidParams.Len() > 0 { 784 return invalidParams 785 } else { 786 return nil 787 } 788} 789 790func validateOpGetDomainDetailInput(v *GetDomainDetailInput) error { 791 if v == nil { 792 return nil 793 } 794 invalidParams := smithy.InvalidParamsError{Context: "GetDomainDetailInput"} 795 if v.DomainName == nil { 796 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 797 } 798 if invalidParams.Len() > 0 { 799 return invalidParams 800 } else { 801 return nil 802 } 803} 804 805func validateOpGetDomainSuggestionsInput(v *GetDomainSuggestionsInput) error { 806 if v == nil { 807 return nil 808 } 809 invalidParams := smithy.InvalidParamsError{Context: "GetDomainSuggestionsInput"} 810 if v.DomainName == nil { 811 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 812 } 813 if v.OnlyAvailable == nil { 814 invalidParams.Add(smithy.NewErrParamRequired("OnlyAvailable")) 815 } 816 if invalidParams.Len() > 0 { 817 return invalidParams 818 } else { 819 return nil 820 } 821} 822 823func validateOpGetOperationDetailInput(v *GetOperationDetailInput) error { 824 if v == nil { 825 return nil 826 } 827 invalidParams := smithy.InvalidParamsError{Context: "GetOperationDetailInput"} 828 if v.OperationId == nil { 829 invalidParams.Add(smithy.NewErrParamRequired("OperationId")) 830 } 831 if invalidParams.Len() > 0 { 832 return invalidParams 833 } else { 834 return nil 835 } 836} 837 838func validateOpListTagsForDomainInput(v *ListTagsForDomainInput) error { 839 if v == nil { 840 return nil 841 } 842 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForDomainInput"} 843 if v.DomainName == nil { 844 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 845 } 846 if invalidParams.Len() > 0 { 847 return invalidParams 848 } else { 849 return nil 850 } 851} 852 853func validateOpRegisterDomainInput(v *RegisterDomainInput) error { 854 if v == nil { 855 return nil 856 } 857 invalidParams := smithy.InvalidParamsError{Context: "RegisterDomainInput"} 858 if v.DomainName == nil { 859 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 860 } 861 if v.DurationInYears == nil { 862 invalidParams.Add(smithy.NewErrParamRequired("DurationInYears")) 863 } 864 if v.AdminContact == nil { 865 invalidParams.Add(smithy.NewErrParamRequired("AdminContact")) 866 } else if v.AdminContact != nil { 867 if err := validateContactDetail(v.AdminContact); err != nil { 868 invalidParams.AddNested("AdminContact", err.(smithy.InvalidParamsError)) 869 } 870 } 871 if v.RegistrantContact == nil { 872 invalidParams.Add(smithy.NewErrParamRequired("RegistrantContact")) 873 } else if v.RegistrantContact != nil { 874 if err := validateContactDetail(v.RegistrantContact); err != nil { 875 invalidParams.AddNested("RegistrantContact", err.(smithy.InvalidParamsError)) 876 } 877 } 878 if v.TechContact == nil { 879 invalidParams.Add(smithy.NewErrParamRequired("TechContact")) 880 } else if v.TechContact != nil { 881 if err := validateContactDetail(v.TechContact); err != nil { 882 invalidParams.AddNested("TechContact", err.(smithy.InvalidParamsError)) 883 } 884 } 885 if invalidParams.Len() > 0 { 886 return invalidParams 887 } else { 888 return nil 889 } 890} 891 892func validateOpRejectDomainTransferFromAnotherAwsAccountInput(v *RejectDomainTransferFromAnotherAwsAccountInput) error { 893 if v == nil { 894 return nil 895 } 896 invalidParams := smithy.InvalidParamsError{Context: "RejectDomainTransferFromAnotherAwsAccountInput"} 897 if v.DomainName == nil { 898 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 899 } 900 if invalidParams.Len() > 0 { 901 return invalidParams 902 } else { 903 return nil 904 } 905} 906 907func validateOpRenewDomainInput(v *RenewDomainInput) error { 908 if v == nil { 909 return nil 910 } 911 invalidParams := smithy.InvalidParamsError{Context: "RenewDomainInput"} 912 if v.DomainName == nil { 913 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 914 } 915 if invalidParams.Len() > 0 { 916 return invalidParams 917 } else { 918 return nil 919 } 920} 921 922func validateOpRetrieveDomainAuthCodeInput(v *RetrieveDomainAuthCodeInput) error { 923 if v == nil { 924 return nil 925 } 926 invalidParams := smithy.InvalidParamsError{Context: "RetrieveDomainAuthCodeInput"} 927 if v.DomainName == nil { 928 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 929 } 930 if invalidParams.Len() > 0 { 931 return invalidParams 932 } else { 933 return nil 934 } 935} 936 937func validateOpTransferDomainInput(v *TransferDomainInput) error { 938 if v == nil { 939 return nil 940 } 941 invalidParams := smithy.InvalidParamsError{Context: "TransferDomainInput"} 942 if v.DomainName == nil { 943 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 944 } 945 if v.DurationInYears == nil { 946 invalidParams.Add(smithy.NewErrParamRequired("DurationInYears")) 947 } 948 if v.Nameservers != nil { 949 if err := validateNameserverList(v.Nameservers); err != nil { 950 invalidParams.AddNested("Nameservers", err.(smithy.InvalidParamsError)) 951 } 952 } 953 if v.AdminContact == nil { 954 invalidParams.Add(smithy.NewErrParamRequired("AdminContact")) 955 } else if v.AdminContact != nil { 956 if err := validateContactDetail(v.AdminContact); err != nil { 957 invalidParams.AddNested("AdminContact", err.(smithy.InvalidParamsError)) 958 } 959 } 960 if v.RegistrantContact == nil { 961 invalidParams.Add(smithy.NewErrParamRequired("RegistrantContact")) 962 } else if v.RegistrantContact != nil { 963 if err := validateContactDetail(v.RegistrantContact); err != nil { 964 invalidParams.AddNested("RegistrantContact", err.(smithy.InvalidParamsError)) 965 } 966 } 967 if v.TechContact == nil { 968 invalidParams.Add(smithy.NewErrParamRequired("TechContact")) 969 } else if v.TechContact != nil { 970 if err := validateContactDetail(v.TechContact); err != nil { 971 invalidParams.AddNested("TechContact", err.(smithy.InvalidParamsError)) 972 } 973 } 974 if invalidParams.Len() > 0 { 975 return invalidParams 976 } else { 977 return nil 978 } 979} 980 981func validateOpTransferDomainToAnotherAwsAccountInput(v *TransferDomainToAnotherAwsAccountInput) error { 982 if v == nil { 983 return nil 984 } 985 invalidParams := smithy.InvalidParamsError{Context: "TransferDomainToAnotherAwsAccountInput"} 986 if v.DomainName == nil { 987 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 988 } 989 if v.AccountId == nil { 990 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 991 } 992 if invalidParams.Len() > 0 { 993 return invalidParams 994 } else { 995 return nil 996 } 997} 998 999func validateOpUpdateDomainContactInput(v *UpdateDomainContactInput) error { 1000 if v == nil { 1001 return nil 1002 } 1003 invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainContactInput"} 1004 if v.DomainName == nil { 1005 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 1006 } 1007 if v.AdminContact != nil { 1008 if err := validateContactDetail(v.AdminContact); err != nil { 1009 invalidParams.AddNested("AdminContact", err.(smithy.InvalidParamsError)) 1010 } 1011 } 1012 if v.RegistrantContact != nil { 1013 if err := validateContactDetail(v.RegistrantContact); err != nil { 1014 invalidParams.AddNested("RegistrantContact", err.(smithy.InvalidParamsError)) 1015 } 1016 } 1017 if v.TechContact != nil { 1018 if err := validateContactDetail(v.TechContact); err != nil { 1019 invalidParams.AddNested("TechContact", err.(smithy.InvalidParamsError)) 1020 } 1021 } 1022 if invalidParams.Len() > 0 { 1023 return invalidParams 1024 } else { 1025 return nil 1026 } 1027} 1028 1029func validateOpUpdateDomainContactPrivacyInput(v *UpdateDomainContactPrivacyInput) error { 1030 if v == nil { 1031 return nil 1032 } 1033 invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainContactPrivacyInput"} 1034 if v.DomainName == nil { 1035 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 1036 } 1037 if invalidParams.Len() > 0 { 1038 return invalidParams 1039 } else { 1040 return nil 1041 } 1042} 1043 1044func validateOpUpdateDomainNameserversInput(v *UpdateDomainNameserversInput) error { 1045 if v == nil { 1046 return nil 1047 } 1048 invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainNameserversInput"} 1049 if v.DomainName == nil { 1050 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 1051 } 1052 if v.Nameservers == nil { 1053 invalidParams.Add(smithy.NewErrParamRequired("Nameservers")) 1054 } else if v.Nameservers != nil { 1055 if err := validateNameserverList(v.Nameservers); err != nil { 1056 invalidParams.AddNested("Nameservers", err.(smithy.InvalidParamsError)) 1057 } 1058 } 1059 if invalidParams.Len() > 0 { 1060 return invalidParams 1061 } else { 1062 return nil 1063 } 1064} 1065 1066func validateOpUpdateTagsForDomainInput(v *UpdateTagsForDomainInput) error { 1067 if v == nil { 1068 return nil 1069 } 1070 invalidParams := smithy.InvalidParamsError{Context: "UpdateTagsForDomainInput"} 1071 if v.DomainName == nil { 1072 invalidParams.Add(smithy.NewErrParamRequired("DomainName")) 1073 } 1074 if invalidParams.Len() > 0 { 1075 return invalidParams 1076 } else { 1077 return nil 1078 } 1079} 1080