1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package directoryservice 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/directoryservice/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsAwsjson11_serializeOpAcceptSharedDirectory struct { 18} 19 20func (*awsAwsjson11_serializeOpAcceptSharedDirectory) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsAwsjson11_serializeOpAcceptSharedDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*AcceptSharedDirectoryInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 request.Request.URL.Path = "/" 39 request.Request.Method = "POST" 40 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 41 if err != nil { 42 return out, metadata, &smithy.SerializationError{Err: err} 43 } 44 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 45 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.AcceptSharedDirectory") 46 47 jsonEncoder := smithyjson.NewEncoder() 48 if err := awsAwsjson11_serializeOpDocumentAcceptSharedDirectoryInput(input, jsonEncoder.Value); err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 53 return out, metadata, &smithy.SerializationError{Err: err} 54 } 55 56 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 57 return out, metadata, &smithy.SerializationError{Err: err} 58 } 59 in.Request = request 60 61 return next.HandleSerialize(ctx, in) 62} 63 64type awsAwsjson11_serializeOpAddIpRoutes struct { 65} 66 67func (*awsAwsjson11_serializeOpAddIpRoutes) ID() string { 68 return "OperationSerializer" 69} 70 71func (m *awsAwsjson11_serializeOpAddIpRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 72 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 73) { 74 request, ok := in.Request.(*smithyhttp.Request) 75 if !ok { 76 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 77 } 78 79 input, ok := in.Parameters.(*AddIpRoutesInput) 80 _ = input 81 if !ok { 82 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 83 } 84 85 request.Request.URL.Path = "/" 86 request.Request.Method = "POST" 87 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 88 if err != nil { 89 return out, metadata, &smithy.SerializationError{Err: err} 90 } 91 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 92 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.AddIpRoutes") 93 94 jsonEncoder := smithyjson.NewEncoder() 95 if err := awsAwsjson11_serializeOpDocumentAddIpRoutesInput(input, jsonEncoder.Value); err != nil { 96 return out, metadata, &smithy.SerializationError{Err: err} 97 } 98 99 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 100 return out, metadata, &smithy.SerializationError{Err: err} 101 } 102 103 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 104 return out, metadata, &smithy.SerializationError{Err: err} 105 } 106 in.Request = request 107 108 return next.HandleSerialize(ctx, in) 109} 110 111type awsAwsjson11_serializeOpAddRegion struct { 112} 113 114func (*awsAwsjson11_serializeOpAddRegion) ID() string { 115 return "OperationSerializer" 116} 117 118func (m *awsAwsjson11_serializeOpAddRegion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 119 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 120) { 121 request, ok := in.Request.(*smithyhttp.Request) 122 if !ok { 123 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 124 } 125 126 input, ok := in.Parameters.(*AddRegionInput) 127 _ = input 128 if !ok { 129 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 130 } 131 132 request.Request.URL.Path = "/" 133 request.Request.Method = "POST" 134 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 135 if err != nil { 136 return out, metadata, &smithy.SerializationError{Err: err} 137 } 138 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 139 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.AddRegion") 140 141 jsonEncoder := smithyjson.NewEncoder() 142 if err := awsAwsjson11_serializeOpDocumentAddRegionInput(input, jsonEncoder.Value); err != nil { 143 return out, metadata, &smithy.SerializationError{Err: err} 144 } 145 146 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 147 return out, metadata, &smithy.SerializationError{Err: err} 148 } 149 150 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 151 return out, metadata, &smithy.SerializationError{Err: err} 152 } 153 in.Request = request 154 155 return next.HandleSerialize(ctx, in) 156} 157 158type awsAwsjson11_serializeOpAddTagsToResource struct { 159} 160 161func (*awsAwsjson11_serializeOpAddTagsToResource) ID() string { 162 return "OperationSerializer" 163} 164 165func (m *awsAwsjson11_serializeOpAddTagsToResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 166 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 167) { 168 request, ok := in.Request.(*smithyhttp.Request) 169 if !ok { 170 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 171 } 172 173 input, ok := in.Parameters.(*AddTagsToResourceInput) 174 _ = input 175 if !ok { 176 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 177 } 178 179 request.Request.URL.Path = "/" 180 request.Request.Method = "POST" 181 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 182 if err != nil { 183 return out, metadata, &smithy.SerializationError{Err: err} 184 } 185 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 186 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.AddTagsToResource") 187 188 jsonEncoder := smithyjson.NewEncoder() 189 if err := awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(input, jsonEncoder.Value); err != nil { 190 return out, metadata, &smithy.SerializationError{Err: err} 191 } 192 193 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 194 return out, metadata, &smithy.SerializationError{Err: err} 195 } 196 197 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 198 return out, metadata, &smithy.SerializationError{Err: err} 199 } 200 in.Request = request 201 202 return next.HandleSerialize(ctx, in) 203} 204 205type awsAwsjson11_serializeOpCancelSchemaExtension struct { 206} 207 208func (*awsAwsjson11_serializeOpCancelSchemaExtension) ID() string { 209 return "OperationSerializer" 210} 211 212func (m *awsAwsjson11_serializeOpCancelSchemaExtension) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 213 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 214) { 215 request, ok := in.Request.(*smithyhttp.Request) 216 if !ok { 217 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 218 } 219 220 input, ok := in.Parameters.(*CancelSchemaExtensionInput) 221 _ = input 222 if !ok { 223 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 224 } 225 226 request.Request.URL.Path = "/" 227 request.Request.Method = "POST" 228 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 229 if err != nil { 230 return out, metadata, &smithy.SerializationError{Err: err} 231 } 232 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 233 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CancelSchemaExtension") 234 235 jsonEncoder := smithyjson.NewEncoder() 236 if err := awsAwsjson11_serializeOpDocumentCancelSchemaExtensionInput(input, jsonEncoder.Value); err != nil { 237 return out, metadata, &smithy.SerializationError{Err: err} 238 } 239 240 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 241 return out, metadata, &smithy.SerializationError{Err: err} 242 } 243 244 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 245 return out, metadata, &smithy.SerializationError{Err: err} 246 } 247 in.Request = request 248 249 return next.HandleSerialize(ctx, in) 250} 251 252type awsAwsjson11_serializeOpConnectDirectory struct { 253} 254 255func (*awsAwsjson11_serializeOpConnectDirectory) ID() string { 256 return "OperationSerializer" 257} 258 259func (m *awsAwsjson11_serializeOpConnectDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 260 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 261) { 262 request, ok := in.Request.(*smithyhttp.Request) 263 if !ok { 264 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 265 } 266 267 input, ok := in.Parameters.(*ConnectDirectoryInput) 268 _ = input 269 if !ok { 270 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 271 } 272 273 request.Request.URL.Path = "/" 274 request.Request.Method = "POST" 275 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 276 if err != nil { 277 return out, metadata, &smithy.SerializationError{Err: err} 278 } 279 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 280 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ConnectDirectory") 281 282 jsonEncoder := smithyjson.NewEncoder() 283 if err := awsAwsjson11_serializeOpDocumentConnectDirectoryInput(input, jsonEncoder.Value); err != nil { 284 return out, metadata, &smithy.SerializationError{Err: err} 285 } 286 287 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 288 return out, metadata, &smithy.SerializationError{Err: err} 289 } 290 291 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 292 return out, metadata, &smithy.SerializationError{Err: err} 293 } 294 in.Request = request 295 296 return next.HandleSerialize(ctx, in) 297} 298 299type awsAwsjson11_serializeOpCreateAlias struct { 300} 301 302func (*awsAwsjson11_serializeOpCreateAlias) ID() string { 303 return "OperationSerializer" 304} 305 306func (m *awsAwsjson11_serializeOpCreateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 307 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 308) { 309 request, ok := in.Request.(*smithyhttp.Request) 310 if !ok { 311 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 312 } 313 314 input, ok := in.Parameters.(*CreateAliasInput) 315 _ = input 316 if !ok { 317 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 318 } 319 320 request.Request.URL.Path = "/" 321 request.Request.Method = "POST" 322 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 323 if err != nil { 324 return out, metadata, &smithy.SerializationError{Err: err} 325 } 326 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 327 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateAlias") 328 329 jsonEncoder := smithyjson.NewEncoder() 330 if err := awsAwsjson11_serializeOpDocumentCreateAliasInput(input, jsonEncoder.Value); err != nil { 331 return out, metadata, &smithy.SerializationError{Err: err} 332 } 333 334 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 335 return out, metadata, &smithy.SerializationError{Err: err} 336 } 337 338 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 339 return out, metadata, &smithy.SerializationError{Err: err} 340 } 341 in.Request = request 342 343 return next.HandleSerialize(ctx, in) 344} 345 346type awsAwsjson11_serializeOpCreateComputer struct { 347} 348 349func (*awsAwsjson11_serializeOpCreateComputer) ID() string { 350 return "OperationSerializer" 351} 352 353func (m *awsAwsjson11_serializeOpCreateComputer) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 354 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 355) { 356 request, ok := in.Request.(*smithyhttp.Request) 357 if !ok { 358 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 359 } 360 361 input, ok := in.Parameters.(*CreateComputerInput) 362 _ = input 363 if !ok { 364 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 365 } 366 367 request.Request.URL.Path = "/" 368 request.Request.Method = "POST" 369 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 370 if err != nil { 371 return out, metadata, &smithy.SerializationError{Err: err} 372 } 373 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 374 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateComputer") 375 376 jsonEncoder := smithyjson.NewEncoder() 377 if err := awsAwsjson11_serializeOpDocumentCreateComputerInput(input, jsonEncoder.Value); err != nil { 378 return out, metadata, &smithy.SerializationError{Err: err} 379 } 380 381 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 382 return out, metadata, &smithy.SerializationError{Err: err} 383 } 384 385 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 386 return out, metadata, &smithy.SerializationError{Err: err} 387 } 388 in.Request = request 389 390 return next.HandleSerialize(ctx, in) 391} 392 393type awsAwsjson11_serializeOpCreateConditionalForwarder struct { 394} 395 396func (*awsAwsjson11_serializeOpCreateConditionalForwarder) ID() string { 397 return "OperationSerializer" 398} 399 400func (m *awsAwsjson11_serializeOpCreateConditionalForwarder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 401 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 402) { 403 request, ok := in.Request.(*smithyhttp.Request) 404 if !ok { 405 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 406 } 407 408 input, ok := in.Parameters.(*CreateConditionalForwarderInput) 409 _ = input 410 if !ok { 411 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 412 } 413 414 request.Request.URL.Path = "/" 415 request.Request.Method = "POST" 416 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 417 if err != nil { 418 return out, metadata, &smithy.SerializationError{Err: err} 419 } 420 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 421 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateConditionalForwarder") 422 423 jsonEncoder := smithyjson.NewEncoder() 424 if err := awsAwsjson11_serializeOpDocumentCreateConditionalForwarderInput(input, jsonEncoder.Value); err != nil { 425 return out, metadata, &smithy.SerializationError{Err: err} 426 } 427 428 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 429 return out, metadata, &smithy.SerializationError{Err: err} 430 } 431 432 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 433 return out, metadata, &smithy.SerializationError{Err: err} 434 } 435 in.Request = request 436 437 return next.HandleSerialize(ctx, in) 438} 439 440type awsAwsjson11_serializeOpCreateDirectory struct { 441} 442 443func (*awsAwsjson11_serializeOpCreateDirectory) ID() string { 444 return "OperationSerializer" 445} 446 447func (m *awsAwsjson11_serializeOpCreateDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 448 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 449) { 450 request, ok := in.Request.(*smithyhttp.Request) 451 if !ok { 452 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 453 } 454 455 input, ok := in.Parameters.(*CreateDirectoryInput) 456 _ = input 457 if !ok { 458 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 459 } 460 461 request.Request.URL.Path = "/" 462 request.Request.Method = "POST" 463 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 464 if err != nil { 465 return out, metadata, &smithy.SerializationError{Err: err} 466 } 467 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 468 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateDirectory") 469 470 jsonEncoder := smithyjson.NewEncoder() 471 if err := awsAwsjson11_serializeOpDocumentCreateDirectoryInput(input, jsonEncoder.Value); err != nil { 472 return out, metadata, &smithy.SerializationError{Err: err} 473 } 474 475 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 476 return out, metadata, &smithy.SerializationError{Err: err} 477 } 478 479 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 480 return out, metadata, &smithy.SerializationError{Err: err} 481 } 482 in.Request = request 483 484 return next.HandleSerialize(ctx, in) 485} 486 487type awsAwsjson11_serializeOpCreateLogSubscription struct { 488} 489 490func (*awsAwsjson11_serializeOpCreateLogSubscription) ID() string { 491 return "OperationSerializer" 492} 493 494func (m *awsAwsjson11_serializeOpCreateLogSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 495 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 496) { 497 request, ok := in.Request.(*smithyhttp.Request) 498 if !ok { 499 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 500 } 501 502 input, ok := in.Parameters.(*CreateLogSubscriptionInput) 503 _ = input 504 if !ok { 505 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 506 } 507 508 request.Request.URL.Path = "/" 509 request.Request.Method = "POST" 510 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 511 if err != nil { 512 return out, metadata, &smithy.SerializationError{Err: err} 513 } 514 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 515 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateLogSubscription") 516 517 jsonEncoder := smithyjson.NewEncoder() 518 if err := awsAwsjson11_serializeOpDocumentCreateLogSubscriptionInput(input, jsonEncoder.Value); err != nil { 519 return out, metadata, &smithy.SerializationError{Err: err} 520 } 521 522 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 523 return out, metadata, &smithy.SerializationError{Err: err} 524 } 525 526 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 527 return out, metadata, &smithy.SerializationError{Err: err} 528 } 529 in.Request = request 530 531 return next.HandleSerialize(ctx, in) 532} 533 534type awsAwsjson11_serializeOpCreateMicrosoftAD struct { 535} 536 537func (*awsAwsjson11_serializeOpCreateMicrosoftAD) ID() string { 538 return "OperationSerializer" 539} 540 541func (m *awsAwsjson11_serializeOpCreateMicrosoftAD) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 542 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 543) { 544 request, ok := in.Request.(*smithyhttp.Request) 545 if !ok { 546 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 547 } 548 549 input, ok := in.Parameters.(*CreateMicrosoftADInput) 550 _ = input 551 if !ok { 552 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 553 } 554 555 request.Request.URL.Path = "/" 556 request.Request.Method = "POST" 557 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 558 if err != nil { 559 return out, metadata, &smithy.SerializationError{Err: err} 560 } 561 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 562 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateMicrosoftAD") 563 564 jsonEncoder := smithyjson.NewEncoder() 565 if err := awsAwsjson11_serializeOpDocumentCreateMicrosoftADInput(input, jsonEncoder.Value); err != nil { 566 return out, metadata, &smithy.SerializationError{Err: err} 567 } 568 569 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 570 return out, metadata, &smithy.SerializationError{Err: err} 571 } 572 573 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 574 return out, metadata, &smithy.SerializationError{Err: err} 575 } 576 in.Request = request 577 578 return next.HandleSerialize(ctx, in) 579} 580 581type awsAwsjson11_serializeOpCreateSnapshot struct { 582} 583 584func (*awsAwsjson11_serializeOpCreateSnapshot) ID() string { 585 return "OperationSerializer" 586} 587 588func (m *awsAwsjson11_serializeOpCreateSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 589 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 590) { 591 request, ok := in.Request.(*smithyhttp.Request) 592 if !ok { 593 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 594 } 595 596 input, ok := in.Parameters.(*CreateSnapshotInput) 597 _ = input 598 if !ok { 599 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 600 } 601 602 request.Request.URL.Path = "/" 603 request.Request.Method = "POST" 604 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 605 if err != nil { 606 return out, metadata, &smithy.SerializationError{Err: err} 607 } 608 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 609 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateSnapshot") 610 611 jsonEncoder := smithyjson.NewEncoder() 612 if err := awsAwsjson11_serializeOpDocumentCreateSnapshotInput(input, jsonEncoder.Value); err != nil { 613 return out, metadata, &smithy.SerializationError{Err: err} 614 } 615 616 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 617 return out, metadata, &smithy.SerializationError{Err: err} 618 } 619 620 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 621 return out, metadata, &smithy.SerializationError{Err: err} 622 } 623 in.Request = request 624 625 return next.HandleSerialize(ctx, in) 626} 627 628type awsAwsjson11_serializeOpCreateTrust struct { 629} 630 631func (*awsAwsjson11_serializeOpCreateTrust) ID() string { 632 return "OperationSerializer" 633} 634 635func (m *awsAwsjson11_serializeOpCreateTrust) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 636 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 637) { 638 request, ok := in.Request.(*smithyhttp.Request) 639 if !ok { 640 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 641 } 642 643 input, ok := in.Parameters.(*CreateTrustInput) 644 _ = input 645 if !ok { 646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 647 } 648 649 request.Request.URL.Path = "/" 650 request.Request.Method = "POST" 651 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 652 if err != nil { 653 return out, metadata, &smithy.SerializationError{Err: err} 654 } 655 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 656 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.CreateTrust") 657 658 jsonEncoder := smithyjson.NewEncoder() 659 if err := awsAwsjson11_serializeOpDocumentCreateTrustInput(input, jsonEncoder.Value); err != nil { 660 return out, metadata, &smithy.SerializationError{Err: err} 661 } 662 663 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 664 return out, metadata, &smithy.SerializationError{Err: err} 665 } 666 667 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 668 return out, metadata, &smithy.SerializationError{Err: err} 669 } 670 in.Request = request 671 672 return next.HandleSerialize(ctx, in) 673} 674 675type awsAwsjson11_serializeOpDeleteConditionalForwarder struct { 676} 677 678func (*awsAwsjson11_serializeOpDeleteConditionalForwarder) ID() string { 679 return "OperationSerializer" 680} 681 682func (m *awsAwsjson11_serializeOpDeleteConditionalForwarder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 683 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 684) { 685 request, ok := in.Request.(*smithyhttp.Request) 686 if !ok { 687 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 688 } 689 690 input, ok := in.Parameters.(*DeleteConditionalForwarderInput) 691 _ = input 692 if !ok { 693 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 694 } 695 696 request.Request.URL.Path = "/" 697 request.Request.Method = "POST" 698 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 699 if err != nil { 700 return out, metadata, &smithy.SerializationError{Err: err} 701 } 702 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 703 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DeleteConditionalForwarder") 704 705 jsonEncoder := smithyjson.NewEncoder() 706 if err := awsAwsjson11_serializeOpDocumentDeleteConditionalForwarderInput(input, jsonEncoder.Value); err != nil { 707 return out, metadata, &smithy.SerializationError{Err: err} 708 } 709 710 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 711 return out, metadata, &smithy.SerializationError{Err: err} 712 } 713 714 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 715 return out, metadata, &smithy.SerializationError{Err: err} 716 } 717 in.Request = request 718 719 return next.HandleSerialize(ctx, in) 720} 721 722type awsAwsjson11_serializeOpDeleteDirectory struct { 723} 724 725func (*awsAwsjson11_serializeOpDeleteDirectory) ID() string { 726 return "OperationSerializer" 727} 728 729func (m *awsAwsjson11_serializeOpDeleteDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 730 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 731) { 732 request, ok := in.Request.(*smithyhttp.Request) 733 if !ok { 734 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 735 } 736 737 input, ok := in.Parameters.(*DeleteDirectoryInput) 738 _ = input 739 if !ok { 740 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 741 } 742 743 request.Request.URL.Path = "/" 744 request.Request.Method = "POST" 745 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 746 if err != nil { 747 return out, metadata, &smithy.SerializationError{Err: err} 748 } 749 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 750 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DeleteDirectory") 751 752 jsonEncoder := smithyjson.NewEncoder() 753 if err := awsAwsjson11_serializeOpDocumentDeleteDirectoryInput(input, jsonEncoder.Value); err != nil { 754 return out, metadata, &smithy.SerializationError{Err: err} 755 } 756 757 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 758 return out, metadata, &smithy.SerializationError{Err: err} 759 } 760 761 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 762 return out, metadata, &smithy.SerializationError{Err: err} 763 } 764 in.Request = request 765 766 return next.HandleSerialize(ctx, in) 767} 768 769type awsAwsjson11_serializeOpDeleteLogSubscription struct { 770} 771 772func (*awsAwsjson11_serializeOpDeleteLogSubscription) ID() string { 773 return "OperationSerializer" 774} 775 776func (m *awsAwsjson11_serializeOpDeleteLogSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 777 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 778) { 779 request, ok := in.Request.(*smithyhttp.Request) 780 if !ok { 781 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 782 } 783 784 input, ok := in.Parameters.(*DeleteLogSubscriptionInput) 785 _ = input 786 if !ok { 787 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 788 } 789 790 request.Request.URL.Path = "/" 791 request.Request.Method = "POST" 792 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 793 if err != nil { 794 return out, metadata, &smithy.SerializationError{Err: err} 795 } 796 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 797 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DeleteLogSubscription") 798 799 jsonEncoder := smithyjson.NewEncoder() 800 if err := awsAwsjson11_serializeOpDocumentDeleteLogSubscriptionInput(input, jsonEncoder.Value); err != nil { 801 return out, metadata, &smithy.SerializationError{Err: err} 802 } 803 804 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 805 return out, metadata, &smithy.SerializationError{Err: err} 806 } 807 808 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 809 return out, metadata, &smithy.SerializationError{Err: err} 810 } 811 in.Request = request 812 813 return next.HandleSerialize(ctx, in) 814} 815 816type awsAwsjson11_serializeOpDeleteSnapshot struct { 817} 818 819func (*awsAwsjson11_serializeOpDeleteSnapshot) ID() string { 820 return "OperationSerializer" 821} 822 823func (m *awsAwsjson11_serializeOpDeleteSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 824 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 825) { 826 request, ok := in.Request.(*smithyhttp.Request) 827 if !ok { 828 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 829 } 830 831 input, ok := in.Parameters.(*DeleteSnapshotInput) 832 _ = input 833 if !ok { 834 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 835 } 836 837 request.Request.URL.Path = "/" 838 request.Request.Method = "POST" 839 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 840 if err != nil { 841 return out, metadata, &smithy.SerializationError{Err: err} 842 } 843 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 844 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DeleteSnapshot") 845 846 jsonEncoder := smithyjson.NewEncoder() 847 if err := awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(input, jsonEncoder.Value); err != nil { 848 return out, metadata, &smithy.SerializationError{Err: err} 849 } 850 851 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 852 return out, metadata, &smithy.SerializationError{Err: err} 853 } 854 855 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 856 return out, metadata, &smithy.SerializationError{Err: err} 857 } 858 in.Request = request 859 860 return next.HandleSerialize(ctx, in) 861} 862 863type awsAwsjson11_serializeOpDeleteTrust struct { 864} 865 866func (*awsAwsjson11_serializeOpDeleteTrust) ID() string { 867 return "OperationSerializer" 868} 869 870func (m *awsAwsjson11_serializeOpDeleteTrust) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 871 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 872) { 873 request, ok := in.Request.(*smithyhttp.Request) 874 if !ok { 875 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 876 } 877 878 input, ok := in.Parameters.(*DeleteTrustInput) 879 _ = input 880 if !ok { 881 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 882 } 883 884 request.Request.URL.Path = "/" 885 request.Request.Method = "POST" 886 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 887 if err != nil { 888 return out, metadata, &smithy.SerializationError{Err: err} 889 } 890 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 891 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DeleteTrust") 892 893 jsonEncoder := smithyjson.NewEncoder() 894 if err := awsAwsjson11_serializeOpDocumentDeleteTrustInput(input, jsonEncoder.Value); err != nil { 895 return out, metadata, &smithy.SerializationError{Err: err} 896 } 897 898 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 899 return out, metadata, &smithy.SerializationError{Err: err} 900 } 901 902 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 903 return out, metadata, &smithy.SerializationError{Err: err} 904 } 905 in.Request = request 906 907 return next.HandleSerialize(ctx, in) 908} 909 910type awsAwsjson11_serializeOpDeregisterCertificate struct { 911} 912 913func (*awsAwsjson11_serializeOpDeregisterCertificate) ID() string { 914 return "OperationSerializer" 915} 916 917func (m *awsAwsjson11_serializeOpDeregisterCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 918 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 919) { 920 request, ok := in.Request.(*smithyhttp.Request) 921 if !ok { 922 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 923 } 924 925 input, ok := in.Parameters.(*DeregisterCertificateInput) 926 _ = input 927 if !ok { 928 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 929 } 930 931 request.Request.URL.Path = "/" 932 request.Request.Method = "POST" 933 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 934 if err != nil { 935 return out, metadata, &smithy.SerializationError{Err: err} 936 } 937 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 938 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DeregisterCertificate") 939 940 jsonEncoder := smithyjson.NewEncoder() 941 if err := awsAwsjson11_serializeOpDocumentDeregisterCertificateInput(input, jsonEncoder.Value); err != nil { 942 return out, metadata, &smithy.SerializationError{Err: err} 943 } 944 945 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 946 return out, metadata, &smithy.SerializationError{Err: err} 947 } 948 949 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 950 return out, metadata, &smithy.SerializationError{Err: err} 951 } 952 in.Request = request 953 954 return next.HandleSerialize(ctx, in) 955} 956 957type awsAwsjson11_serializeOpDeregisterEventTopic struct { 958} 959 960func (*awsAwsjson11_serializeOpDeregisterEventTopic) ID() string { 961 return "OperationSerializer" 962} 963 964func (m *awsAwsjson11_serializeOpDeregisterEventTopic) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 965 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 966) { 967 request, ok := in.Request.(*smithyhttp.Request) 968 if !ok { 969 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 970 } 971 972 input, ok := in.Parameters.(*DeregisterEventTopicInput) 973 _ = input 974 if !ok { 975 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 976 } 977 978 request.Request.URL.Path = "/" 979 request.Request.Method = "POST" 980 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 981 if err != nil { 982 return out, metadata, &smithy.SerializationError{Err: err} 983 } 984 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 985 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DeregisterEventTopic") 986 987 jsonEncoder := smithyjson.NewEncoder() 988 if err := awsAwsjson11_serializeOpDocumentDeregisterEventTopicInput(input, jsonEncoder.Value); err != nil { 989 return out, metadata, &smithy.SerializationError{Err: err} 990 } 991 992 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 993 return out, metadata, &smithy.SerializationError{Err: err} 994 } 995 996 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 997 return out, metadata, &smithy.SerializationError{Err: err} 998 } 999 in.Request = request 1000 1001 return next.HandleSerialize(ctx, in) 1002} 1003 1004type awsAwsjson11_serializeOpDescribeCertificate struct { 1005} 1006 1007func (*awsAwsjson11_serializeOpDescribeCertificate) ID() string { 1008 return "OperationSerializer" 1009} 1010 1011func (m *awsAwsjson11_serializeOpDescribeCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1012 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1013) { 1014 request, ok := in.Request.(*smithyhttp.Request) 1015 if !ok { 1016 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1017 } 1018 1019 input, ok := in.Parameters.(*DescribeCertificateInput) 1020 _ = input 1021 if !ok { 1022 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1023 } 1024 1025 request.Request.URL.Path = "/" 1026 request.Request.Method = "POST" 1027 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1028 if err != nil { 1029 return out, metadata, &smithy.SerializationError{Err: err} 1030 } 1031 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1032 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeCertificate") 1033 1034 jsonEncoder := smithyjson.NewEncoder() 1035 if err := awsAwsjson11_serializeOpDocumentDescribeCertificateInput(input, jsonEncoder.Value); err != nil { 1036 return out, metadata, &smithy.SerializationError{Err: err} 1037 } 1038 1039 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1040 return out, metadata, &smithy.SerializationError{Err: err} 1041 } 1042 1043 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1044 return out, metadata, &smithy.SerializationError{Err: err} 1045 } 1046 in.Request = request 1047 1048 return next.HandleSerialize(ctx, in) 1049} 1050 1051type awsAwsjson11_serializeOpDescribeConditionalForwarders struct { 1052} 1053 1054func (*awsAwsjson11_serializeOpDescribeConditionalForwarders) ID() string { 1055 return "OperationSerializer" 1056} 1057 1058func (m *awsAwsjson11_serializeOpDescribeConditionalForwarders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1059 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1060) { 1061 request, ok := in.Request.(*smithyhttp.Request) 1062 if !ok { 1063 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1064 } 1065 1066 input, ok := in.Parameters.(*DescribeConditionalForwardersInput) 1067 _ = input 1068 if !ok { 1069 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1070 } 1071 1072 request.Request.URL.Path = "/" 1073 request.Request.Method = "POST" 1074 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1075 if err != nil { 1076 return out, metadata, &smithy.SerializationError{Err: err} 1077 } 1078 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1079 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeConditionalForwarders") 1080 1081 jsonEncoder := smithyjson.NewEncoder() 1082 if err := awsAwsjson11_serializeOpDocumentDescribeConditionalForwardersInput(input, jsonEncoder.Value); err != nil { 1083 return out, metadata, &smithy.SerializationError{Err: err} 1084 } 1085 1086 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1087 return out, metadata, &smithy.SerializationError{Err: err} 1088 } 1089 1090 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1091 return out, metadata, &smithy.SerializationError{Err: err} 1092 } 1093 in.Request = request 1094 1095 return next.HandleSerialize(ctx, in) 1096} 1097 1098type awsAwsjson11_serializeOpDescribeDirectories struct { 1099} 1100 1101func (*awsAwsjson11_serializeOpDescribeDirectories) ID() string { 1102 return "OperationSerializer" 1103} 1104 1105func (m *awsAwsjson11_serializeOpDescribeDirectories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1106 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1107) { 1108 request, ok := in.Request.(*smithyhttp.Request) 1109 if !ok { 1110 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1111 } 1112 1113 input, ok := in.Parameters.(*DescribeDirectoriesInput) 1114 _ = input 1115 if !ok { 1116 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1117 } 1118 1119 request.Request.URL.Path = "/" 1120 request.Request.Method = "POST" 1121 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1122 if err != nil { 1123 return out, metadata, &smithy.SerializationError{Err: err} 1124 } 1125 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1126 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeDirectories") 1127 1128 jsonEncoder := smithyjson.NewEncoder() 1129 if err := awsAwsjson11_serializeOpDocumentDescribeDirectoriesInput(input, jsonEncoder.Value); err != nil { 1130 return out, metadata, &smithy.SerializationError{Err: err} 1131 } 1132 1133 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1134 return out, metadata, &smithy.SerializationError{Err: err} 1135 } 1136 1137 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1138 return out, metadata, &smithy.SerializationError{Err: err} 1139 } 1140 in.Request = request 1141 1142 return next.HandleSerialize(ctx, in) 1143} 1144 1145type awsAwsjson11_serializeOpDescribeDomainControllers struct { 1146} 1147 1148func (*awsAwsjson11_serializeOpDescribeDomainControllers) ID() string { 1149 return "OperationSerializer" 1150} 1151 1152func (m *awsAwsjson11_serializeOpDescribeDomainControllers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1153 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1154) { 1155 request, ok := in.Request.(*smithyhttp.Request) 1156 if !ok { 1157 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1158 } 1159 1160 input, ok := in.Parameters.(*DescribeDomainControllersInput) 1161 _ = input 1162 if !ok { 1163 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1164 } 1165 1166 request.Request.URL.Path = "/" 1167 request.Request.Method = "POST" 1168 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1169 if err != nil { 1170 return out, metadata, &smithy.SerializationError{Err: err} 1171 } 1172 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1173 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeDomainControllers") 1174 1175 jsonEncoder := smithyjson.NewEncoder() 1176 if err := awsAwsjson11_serializeOpDocumentDescribeDomainControllersInput(input, jsonEncoder.Value); err != nil { 1177 return out, metadata, &smithy.SerializationError{Err: err} 1178 } 1179 1180 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1181 return out, metadata, &smithy.SerializationError{Err: err} 1182 } 1183 1184 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1185 return out, metadata, &smithy.SerializationError{Err: err} 1186 } 1187 in.Request = request 1188 1189 return next.HandleSerialize(ctx, in) 1190} 1191 1192type awsAwsjson11_serializeOpDescribeEventTopics struct { 1193} 1194 1195func (*awsAwsjson11_serializeOpDescribeEventTopics) ID() string { 1196 return "OperationSerializer" 1197} 1198 1199func (m *awsAwsjson11_serializeOpDescribeEventTopics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1200 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1201) { 1202 request, ok := in.Request.(*smithyhttp.Request) 1203 if !ok { 1204 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1205 } 1206 1207 input, ok := in.Parameters.(*DescribeEventTopicsInput) 1208 _ = input 1209 if !ok { 1210 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1211 } 1212 1213 request.Request.URL.Path = "/" 1214 request.Request.Method = "POST" 1215 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1216 if err != nil { 1217 return out, metadata, &smithy.SerializationError{Err: err} 1218 } 1219 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1220 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeEventTopics") 1221 1222 jsonEncoder := smithyjson.NewEncoder() 1223 if err := awsAwsjson11_serializeOpDocumentDescribeEventTopicsInput(input, jsonEncoder.Value); err != nil { 1224 return out, metadata, &smithy.SerializationError{Err: err} 1225 } 1226 1227 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1228 return out, metadata, &smithy.SerializationError{Err: err} 1229 } 1230 1231 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1232 return out, metadata, &smithy.SerializationError{Err: err} 1233 } 1234 in.Request = request 1235 1236 return next.HandleSerialize(ctx, in) 1237} 1238 1239type awsAwsjson11_serializeOpDescribeLDAPSSettings struct { 1240} 1241 1242func (*awsAwsjson11_serializeOpDescribeLDAPSSettings) ID() string { 1243 return "OperationSerializer" 1244} 1245 1246func (m *awsAwsjson11_serializeOpDescribeLDAPSSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1247 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1248) { 1249 request, ok := in.Request.(*smithyhttp.Request) 1250 if !ok { 1251 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1252 } 1253 1254 input, ok := in.Parameters.(*DescribeLDAPSSettingsInput) 1255 _ = input 1256 if !ok { 1257 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1258 } 1259 1260 request.Request.URL.Path = "/" 1261 request.Request.Method = "POST" 1262 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1263 if err != nil { 1264 return out, metadata, &smithy.SerializationError{Err: err} 1265 } 1266 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1267 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeLDAPSSettings") 1268 1269 jsonEncoder := smithyjson.NewEncoder() 1270 if err := awsAwsjson11_serializeOpDocumentDescribeLDAPSSettingsInput(input, jsonEncoder.Value); err != nil { 1271 return out, metadata, &smithy.SerializationError{Err: err} 1272 } 1273 1274 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1275 return out, metadata, &smithy.SerializationError{Err: err} 1276 } 1277 1278 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1279 return out, metadata, &smithy.SerializationError{Err: err} 1280 } 1281 in.Request = request 1282 1283 return next.HandleSerialize(ctx, in) 1284} 1285 1286type awsAwsjson11_serializeOpDescribeRegions struct { 1287} 1288 1289func (*awsAwsjson11_serializeOpDescribeRegions) ID() string { 1290 return "OperationSerializer" 1291} 1292 1293func (m *awsAwsjson11_serializeOpDescribeRegions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1294 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1295) { 1296 request, ok := in.Request.(*smithyhttp.Request) 1297 if !ok { 1298 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1299 } 1300 1301 input, ok := in.Parameters.(*DescribeRegionsInput) 1302 _ = input 1303 if !ok { 1304 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1305 } 1306 1307 request.Request.URL.Path = "/" 1308 request.Request.Method = "POST" 1309 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1310 if err != nil { 1311 return out, metadata, &smithy.SerializationError{Err: err} 1312 } 1313 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1314 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeRegions") 1315 1316 jsonEncoder := smithyjson.NewEncoder() 1317 if err := awsAwsjson11_serializeOpDocumentDescribeRegionsInput(input, jsonEncoder.Value); err != nil { 1318 return out, metadata, &smithy.SerializationError{Err: err} 1319 } 1320 1321 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1322 return out, metadata, &smithy.SerializationError{Err: err} 1323 } 1324 1325 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1326 return out, metadata, &smithy.SerializationError{Err: err} 1327 } 1328 in.Request = request 1329 1330 return next.HandleSerialize(ctx, in) 1331} 1332 1333type awsAwsjson11_serializeOpDescribeSharedDirectories struct { 1334} 1335 1336func (*awsAwsjson11_serializeOpDescribeSharedDirectories) ID() string { 1337 return "OperationSerializer" 1338} 1339 1340func (m *awsAwsjson11_serializeOpDescribeSharedDirectories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1341 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1342) { 1343 request, ok := in.Request.(*smithyhttp.Request) 1344 if !ok { 1345 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1346 } 1347 1348 input, ok := in.Parameters.(*DescribeSharedDirectoriesInput) 1349 _ = input 1350 if !ok { 1351 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1352 } 1353 1354 request.Request.URL.Path = "/" 1355 request.Request.Method = "POST" 1356 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1357 if err != nil { 1358 return out, metadata, &smithy.SerializationError{Err: err} 1359 } 1360 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1361 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeSharedDirectories") 1362 1363 jsonEncoder := smithyjson.NewEncoder() 1364 if err := awsAwsjson11_serializeOpDocumentDescribeSharedDirectoriesInput(input, jsonEncoder.Value); err != nil { 1365 return out, metadata, &smithy.SerializationError{Err: err} 1366 } 1367 1368 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1369 return out, metadata, &smithy.SerializationError{Err: err} 1370 } 1371 1372 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1373 return out, metadata, &smithy.SerializationError{Err: err} 1374 } 1375 in.Request = request 1376 1377 return next.HandleSerialize(ctx, in) 1378} 1379 1380type awsAwsjson11_serializeOpDescribeSnapshots struct { 1381} 1382 1383func (*awsAwsjson11_serializeOpDescribeSnapshots) ID() string { 1384 return "OperationSerializer" 1385} 1386 1387func (m *awsAwsjson11_serializeOpDescribeSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1388 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1389) { 1390 request, ok := in.Request.(*smithyhttp.Request) 1391 if !ok { 1392 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1393 } 1394 1395 input, ok := in.Parameters.(*DescribeSnapshotsInput) 1396 _ = input 1397 if !ok { 1398 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1399 } 1400 1401 request.Request.URL.Path = "/" 1402 request.Request.Method = "POST" 1403 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1404 if err != nil { 1405 return out, metadata, &smithy.SerializationError{Err: err} 1406 } 1407 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1408 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeSnapshots") 1409 1410 jsonEncoder := smithyjson.NewEncoder() 1411 if err := awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(input, jsonEncoder.Value); err != nil { 1412 return out, metadata, &smithy.SerializationError{Err: err} 1413 } 1414 1415 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1416 return out, metadata, &smithy.SerializationError{Err: err} 1417 } 1418 1419 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1420 return out, metadata, &smithy.SerializationError{Err: err} 1421 } 1422 in.Request = request 1423 1424 return next.HandleSerialize(ctx, in) 1425} 1426 1427type awsAwsjson11_serializeOpDescribeTrusts struct { 1428} 1429 1430func (*awsAwsjson11_serializeOpDescribeTrusts) ID() string { 1431 return "OperationSerializer" 1432} 1433 1434func (m *awsAwsjson11_serializeOpDescribeTrusts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1435 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1436) { 1437 request, ok := in.Request.(*smithyhttp.Request) 1438 if !ok { 1439 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1440 } 1441 1442 input, ok := in.Parameters.(*DescribeTrustsInput) 1443 _ = input 1444 if !ok { 1445 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1446 } 1447 1448 request.Request.URL.Path = "/" 1449 request.Request.Method = "POST" 1450 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1451 if err != nil { 1452 return out, metadata, &smithy.SerializationError{Err: err} 1453 } 1454 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1455 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DescribeTrusts") 1456 1457 jsonEncoder := smithyjson.NewEncoder() 1458 if err := awsAwsjson11_serializeOpDocumentDescribeTrustsInput(input, jsonEncoder.Value); err != nil { 1459 return out, metadata, &smithy.SerializationError{Err: err} 1460 } 1461 1462 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1463 return out, metadata, &smithy.SerializationError{Err: err} 1464 } 1465 1466 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1467 return out, metadata, &smithy.SerializationError{Err: err} 1468 } 1469 in.Request = request 1470 1471 return next.HandleSerialize(ctx, in) 1472} 1473 1474type awsAwsjson11_serializeOpDisableClientAuthentication struct { 1475} 1476 1477func (*awsAwsjson11_serializeOpDisableClientAuthentication) ID() string { 1478 return "OperationSerializer" 1479} 1480 1481func (m *awsAwsjson11_serializeOpDisableClientAuthentication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1482 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1483) { 1484 request, ok := in.Request.(*smithyhttp.Request) 1485 if !ok { 1486 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1487 } 1488 1489 input, ok := in.Parameters.(*DisableClientAuthenticationInput) 1490 _ = input 1491 if !ok { 1492 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1493 } 1494 1495 request.Request.URL.Path = "/" 1496 request.Request.Method = "POST" 1497 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1498 if err != nil { 1499 return out, metadata, &smithy.SerializationError{Err: err} 1500 } 1501 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1502 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DisableClientAuthentication") 1503 1504 jsonEncoder := smithyjson.NewEncoder() 1505 if err := awsAwsjson11_serializeOpDocumentDisableClientAuthenticationInput(input, jsonEncoder.Value); err != nil { 1506 return out, metadata, &smithy.SerializationError{Err: err} 1507 } 1508 1509 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1510 return out, metadata, &smithy.SerializationError{Err: err} 1511 } 1512 1513 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1514 return out, metadata, &smithy.SerializationError{Err: err} 1515 } 1516 in.Request = request 1517 1518 return next.HandleSerialize(ctx, in) 1519} 1520 1521type awsAwsjson11_serializeOpDisableLDAPS struct { 1522} 1523 1524func (*awsAwsjson11_serializeOpDisableLDAPS) ID() string { 1525 return "OperationSerializer" 1526} 1527 1528func (m *awsAwsjson11_serializeOpDisableLDAPS) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1529 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1530) { 1531 request, ok := in.Request.(*smithyhttp.Request) 1532 if !ok { 1533 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1534 } 1535 1536 input, ok := in.Parameters.(*DisableLDAPSInput) 1537 _ = input 1538 if !ok { 1539 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1540 } 1541 1542 request.Request.URL.Path = "/" 1543 request.Request.Method = "POST" 1544 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1545 if err != nil { 1546 return out, metadata, &smithy.SerializationError{Err: err} 1547 } 1548 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1549 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DisableLDAPS") 1550 1551 jsonEncoder := smithyjson.NewEncoder() 1552 if err := awsAwsjson11_serializeOpDocumentDisableLDAPSInput(input, jsonEncoder.Value); err != nil { 1553 return out, metadata, &smithy.SerializationError{Err: err} 1554 } 1555 1556 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1557 return out, metadata, &smithy.SerializationError{Err: err} 1558 } 1559 1560 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1561 return out, metadata, &smithy.SerializationError{Err: err} 1562 } 1563 in.Request = request 1564 1565 return next.HandleSerialize(ctx, in) 1566} 1567 1568type awsAwsjson11_serializeOpDisableRadius struct { 1569} 1570 1571func (*awsAwsjson11_serializeOpDisableRadius) ID() string { 1572 return "OperationSerializer" 1573} 1574 1575func (m *awsAwsjson11_serializeOpDisableRadius) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1576 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1577) { 1578 request, ok := in.Request.(*smithyhttp.Request) 1579 if !ok { 1580 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1581 } 1582 1583 input, ok := in.Parameters.(*DisableRadiusInput) 1584 _ = input 1585 if !ok { 1586 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1587 } 1588 1589 request.Request.URL.Path = "/" 1590 request.Request.Method = "POST" 1591 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1592 if err != nil { 1593 return out, metadata, &smithy.SerializationError{Err: err} 1594 } 1595 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1596 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DisableRadius") 1597 1598 jsonEncoder := smithyjson.NewEncoder() 1599 if err := awsAwsjson11_serializeOpDocumentDisableRadiusInput(input, jsonEncoder.Value); err != nil { 1600 return out, metadata, &smithy.SerializationError{Err: err} 1601 } 1602 1603 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1604 return out, metadata, &smithy.SerializationError{Err: err} 1605 } 1606 1607 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1608 return out, metadata, &smithy.SerializationError{Err: err} 1609 } 1610 in.Request = request 1611 1612 return next.HandleSerialize(ctx, in) 1613} 1614 1615type awsAwsjson11_serializeOpDisableSso struct { 1616} 1617 1618func (*awsAwsjson11_serializeOpDisableSso) ID() string { 1619 return "OperationSerializer" 1620} 1621 1622func (m *awsAwsjson11_serializeOpDisableSso) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1623 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1624) { 1625 request, ok := in.Request.(*smithyhttp.Request) 1626 if !ok { 1627 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1628 } 1629 1630 input, ok := in.Parameters.(*DisableSsoInput) 1631 _ = input 1632 if !ok { 1633 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1634 } 1635 1636 request.Request.URL.Path = "/" 1637 request.Request.Method = "POST" 1638 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1639 if err != nil { 1640 return out, metadata, &smithy.SerializationError{Err: err} 1641 } 1642 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1643 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.DisableSso") 1644 1645 jsonEncoder := smithyjson.NewEncoder() 1646 if err := awsAwsjson11_serializeOpDocumentDisableSsoInput(input, jsonEncoder.Value); err != nil { 1647 return out, metadata, &smithy.SerializationError{Err: err} 1648 } 1649 1650 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1651 return out, metadata, &smithy.SerializationError{Err: err} 1652 } 1653 1654 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1655 return out, metadata, &smithy.SerializationError{Err: err} 1656 } 1657 in.Request = request 1658 1659 return next.HandleSerialize(ctx, in) 1660} 1661 1662type awsAwsjson11_serializeOpEnableClientAuthentication struct { 1663} 1664 1665func (*awsAwsjson11_serializeOpEnableClientAuthentication) ID() string { 1666 return "OperationSerializer" 1667} 1668 1669func (m *awsAwsjson11_serializeOpEnableClientAuthentication) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1670 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1671) { 1672 request, ok := in.Request.(*smithyhttp.Request) 1673 if !ok { 1674 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1675 } 1676 1677 input, ok := in.Parameters.(*EnableClientAuthenticationInput) 1678 _ = input 1679 if !ok { 1680 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1681 } 1682 1683 request.Request.URL.Path = "/" 1684 request.Request.Method = "POST" 1685 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1686 if err != nil { 1687 return out, metadata, &smithy.SerializationError{Err: err} 1688 } 1689 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1690 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.EnableClientAuthentication") 1691 1692 jsonEncoder := smithyjson.NewEncoder() 1693 if err := awsAwsjson11_serializeOpDocumentEnableClientAuthenticationInput(input, jsonEncoder.Value); err != nil { 1694 return out, metadata, &smithy.SerializationError{Err: err} 1695 } 1696 1697 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1698 return out, metadata, &smithy.SerializationError{Err: err} 1699 } 1700 1701 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1702 return out, metadata, &smithy.SerializationError{Err: err} 1703 } 1704 in.Request = request 1705 1706 return next.HandleSerialize(ctx, in) 1707} 1708 1709type awsAwsjson11_serializeOpEnableLDAPS struct { 1710} 1711 1712func (*awsAwsjson11_serializeOpEnableLDAPS) ID() string { 1713 return "OperationSerializer" 1714} 1715 1716func (m *awsAwsjson11_serializeOpEnableLDAPS) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1717 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1718) { 1719 request, ok := in.Request.(*smithyhttp.Request) 1720 if !ok { 1721 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1722 } 1723 1724 input, ok := in.Parameters.(*EnableLDAPSInput) 1725 _ = input 1726 if !ok { 1727 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1728 } 1729 1730 request.Request.URL.Path = "/" 1731 request.Request.Method = "POST" 1732 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1733 if err != nil { 1734 return out, metadata, &smithy.SerializationError{Err: err} 1735 } 1736 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1737 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.EnableLDAPS") 1738 1739 jsonEncoder := smithyjson.NewEncoder() 1740 if err := awsAwsjson11_serializeOpDocumentEnableLDAPSInput(input, jsonEncoder.Value); err != nil { 1741 return out, metadata, &smithy.SerializationError{Err: err} 1742 } 1743 1744 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1745 return out, metadata, &smithy.SerializationError{Err: err} 1746 } 1747 1748 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1749 return out, metadata, &smithy.SerializationError{Err: err} 1750 } 1751 in.Request = request 1752 1753 return next.HandleSerialize(ctx, in) 1754} 1755 1756type awsAwsjson11_serializeOpEnableRadius struct { 1757} 1758 1759func (*awsAwsjson11_serializeOpEnableRadius) ID() string { 1760 return "OperationSerializer" 1761} 1762 1763func (m *awsAwsjson11_serializeOpEnableRadius) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1764 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1765) { 1766 request, ok := in.Request.(*smithyhttp.Request) 1767 if !ok { 1768 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1769 } 1770 1771 input, ok := in.Parameters.(*EnableRadiusInput) 1772 _ = input 1773 if !ok { 1774 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1775 } 1776 1777 request.Request.URL.Path = "/" 1778 request.Request.Method = "POST" 1779 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1780 if err != nil { 1781 return out, metadata, &smithy.SerializationError{Err: err} 1782 } 1783 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1784 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.EnableRadius") 1785 1786 jsonEncoder := smithyjson.NewEncoder() 1787 if err := awsAwsjson11_serializeOpDocumentEnableRadiusInput(input, jsonEncoder.Value); err != nil { 1788 return out, metadata, &smithy.SerializationError{Err: err} 1789 } 1790 1791 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1792 return out, metadata, &smithy.SerializationError{Err: err} 1793 } 1794 1795 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1796 return out, metadata, &smithy.SerializationError{Err: err} 1797 } 1798 in.Request = request 1799 1800 return next.HandleSerialize(ctx, in) 1801} 1802 1803type awsAwsjson11_serializeOpEnableSso struct { 1804} 1805 1806func (*awsAwsjson11_serializeOpEnableSso) ID() string { 1807 return "OperationSerializer" 1808} 1809 1810func (m *awsAwsjson11_serializeOpEnableSso) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1811 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1812) { 1813 request, ok := in.Request.(*smithyhttp.Request) 1814 if !ok { 1815 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1816 } 1817 1818 input, ok := in.Parameters.(*EnableSsoInput) 1819 _ = input 1820 if !ok { 1821 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1822 } 1823 1824 request.Request.URL.Path = "/" 1825 request.Request.Method = "POST" 1826 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1827 if err != nil { 1828 return out, metadata, &smithy.SerializationError{Err: err} 1829 } 1830 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1831 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.EnableSso") 1832 1833 jsonEncoder := smithyjson.NewEncoder() 1834 if err := awsAwsjson11_serializeOpDocumentEnableSsoInput(input, jsonEncoder.Value); err != nil { 1835 return out, metadata, &smithy.SerializationError{Err: err} 1836 } 1837 1838 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1839 return out, metadata, &smithy.SerializationError{Err: err} 1840 } 1841 1842 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1843 return out, metadata, &smithy.SerializationError{Err: err} 1844 } 1845 in.Request = request 1846 1847 return next.HandleSerialize(ctx, in) 1848} 1849 1850type awsAwsjson11_serializeOpGetDirectoryLimits struct { 1851} 1852 1853func (*awsAwsjson11_serializeOpGetDirectoryLimits) ID() string { 1854 return "OperationSerializer" 1855} 1856 1857func (m *awsAwsjson11_serializeOpGetDirectoryLimits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1858 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1859) { 1860 request, ok := in.Request.(*smithyhttp.Request) 1861 if !ok { 1862 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1863 } 1864 1865 input, ok := in.Parameters.(*GetDirectoryLimitsInput) 1866 _ = input 1867 if !ok { 1868 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1869 } 1870 1871 request.Request.URL.Path = "/" 1872 request.Request.Method = "POST" 1873 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1874 if err != nil { 1875 return out, metadata, &smithy.SerializationError{Err: err} 1876 } 1877 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1878 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.GetDirectoryLimits") 1879 1880 jsonEncoder := smithyjson.NewEncoder() 1881 if err := awsAwsjson11_serializeOpDocumentGetDirectoryLimitsInput(input, jsonEncoder.Value); err != nil { 1882 return out, metadata, &smithy.SerializationError{Err: err} 1883 } 1884 1885 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1886 return out, metadata, &smithy.SerializationError{Err: err} 1887 } 1888 1889 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1890 return out, metadata, &smithy.SerializationError{Err: err} 1891 } 1892 in.Request = request 1893 1894 return next.HandleSerialize(ctx, in) 1895} 1896 1897type awsAwsjson11_serializeOpGetSnapshotLimits struct { 1898} 1899 1900func (*awsAwsjson11_serializeOpGetSnapshotLimits) ID() string { 1901 return "OperationSerializer" 1902} 1903 1904func (m *awsAwsjson11_serializeOpGetSnapshotLimits) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1905 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1906) { 1907 request, ok := in.Request.(*smithyhttp.Request) 1908 if !ok { 1909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1910 } 1911 1912 input, ok := in.Parameters.(*GetSnapshotLimitsInput) 1913 _ = input 1914 if !ok { 1915 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1916 } 1917 1918 request.Request.URL.Path = "/" 1919 request.Request.Method = "POST" 1920 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1921 if err != nil { 1922 return out, metadata, &smithy.SerializationError{Err: err} 1923 } 1924 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1925 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.GetSnapshotLimits") 1926 1927 jsonEncoder := smithyjson.NewEncoder() 1928 if err := awsAwsjson11_serializeOpDocumentGetSnapshotLimitsInput(input, jsonEncoder.Value); err != nil { 1929 return out, metadata, &smithy.SerializationError{Err: err} 1930 } 1931 1932 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1933 return out, metadata, &smithy.SerializationError{Err: err} 1934 } 1935 1936 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1937 return out, metadata, &smithy.SerializationError{Err: err} 1938 } 1939 in.Request = request 1940 1941 return next.HandleSerialize(ctx, in) 1942} 1943 1944type awsAwsjson11_serializeOpListCertificates struct { 1945} 1946 1947func (*awsAwsjson11_serializeOpListCertificates) ID() string { 1948 return "OperationSerializer" 1949} 1950 1951func (m *awsAwsjson11_serializeOpListCertificates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1952 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1953) { 1954 request, ok := in.Request.(*smithyhttp.Request) 1955 if !ok { 1956 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1957 } 1958 1959 input, ok := in.Parameters.(*ListCertificatesInput) 1960 _ = input 1961 if !ok { 1962 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1963 } 1964 1965 request.Request.URL.Path = "/" 1966 request.Request.Method = "POST" 1967 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1968 if err != nil { 1969 return out, metadata, &smithy.SerializationError{Err: err} 1970 } 1971 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1972 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ListCertificates") 1973 1974 jsonEncoder := smithyjson.NewEncoder() 1975 if err := awsAwsjson11_serializeOpDocumentListCertificatesInput(input, jsonEncoder.Value); err != nil { 1976 return out, metadata, &smithy.SerializationError{Err: err} 1977 } 1978 1979 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1980 return out, metadata, &smithy.SerializationError{Err: err} 1981 } 1982 1983 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1984 return out, metadata, &smithy.SerializationError{Err: err} 1985 } 1986 in.Request = request 1987 1988 return next.HandleSerialize(ctx, in) 1989} 1990 1991type awsAwsjson11_serializeOpListIpRoutes struct { 1992} 1993 1994func (*awsAwsjson11_serializeOpListIpRoutes) ID() string { 1995 return "OperationSerializer" 1996} 1997 1998func (m *awsAwsjson11_serializeOpListIpRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1999 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2000) { 2001 request, ok := in.Request.(*smithyhttp.Request) 2002 if !ok { 2003 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2004 } 2005 2006 input, ok := in.Parameters.(*ListIpRoutesInput) 2007 _ = input 2008 if !ok { 2009 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2010 } 2011 2012 request.Request.URL.Path = "/" 2013 request.Request.Method = "POST" 2014 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2015 if err != nil { 2016 return out, metadata, &smithy.SerializationError{Err: err} 2017 } 2018 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2019 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ListIpRoutes") 2020 2021 jsonEncoder := smithyjson.NewEncoder() 2022 if err := awsAwsjson11_serializeOpDocumentListIpRoutesInput(input, jsonEncoder.Value); err != nil { 2023 return out, metadata, &smithy.SerializationError{Err: err} 2024 } 2025 2026 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2027 return out, metadata, &smithy.SerializationError{Err: err} 2028 } 2029 2030 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2031 return out, metadata, &smithy.SerializationError{Err: err} 2032 } 2033 in.Request = request 2034 2035 return next.HandleSerialize(ctx, in) 2036} 2037 2038type awsAwsjson11_serializeOpListLogSubscriptions struct { 2039} 2040 2041func (*awsAwsjson11_serializeOpListLogSubscriptions) ID() string { 2042 return "OperationSerializer" 2043} 2044 2045func (m *awsAwsjson11_serializeOpListLogSubscriptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2046 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2047) { 2048 request, ok := in.Request.(*smithyhttp.Request) 2049 if !ok { 2050 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2051 } 2052 2053 input, ok := in.Parameters.(*ListLogSubscriptionsInput) 2054 _ = input 2055 if !ok { 2056 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2057 } 2058 2059 request.Request.URL.Path = "/" 2060 request.Request.Method = "POST" 2061 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2062 if err != nil { 2063 return out, metadata, &smithy.SerializationError{Err: err} 2064 } 2065 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2066 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ListLogSubscriptions") 2067 2068 jsonEncoder := smithyjson.NewEncoder() 2069 if err := awsAwsjson11_serializeOpDocumentListLogSubscriptionsInput(input, jsonEncoder.Value); err != nil { 2070 return out, metadata, &smithy.SerializationError{Err: err} 2071 } 2072 2073 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2074 return out, metadata, &smithy.SerializationError{Err: err} 2075 } 2076 2077 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2078 return out, metadata, &smithy.SerializationError{Err: err} 2079 } 2080 in.Request = request 2081 2082 return next.HandleSerialize(ctx, in) 2083} 2084 2085type awsAwsjson11_serializeOpListSchemaExtensions struct { 2086} 2087 2088func (*awsAwsjson11_serializeOpListSchemaExtensions) ID() string { 2089 return "OperationSerializer" 2090} 2091 2092func (m *awsAwsjson11_serializeOpListSchemaExtensions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2093 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2094) { 2095 request, ok := in.Request.(*smithyhttp.Request) 2096 if !ok { 2097 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2098 } 2099 2100 input, ok := in.Parameters.(*ListSchemaExtensionsInput) 2101 _ = input 2102 if !ok { 2103 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2104 } 2105 2106 request.Request.URL.Path = "/" 2107 request.Request.Method = "POST" 2108 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2109 if err != nil { 2110 return out, metadata, &smithy.SerializationError{Err: err} 2111 } 2112 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2113 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ListSchemaExtensions") 2114 2115 jsonEncoder := smithyjson.NewEncoder() 2116 if err := awsAwsjson11_serializeOpDocumentListSchemaExtensionsInput(input, jsonEncoder.Value); err != nil { 2117 return out, metadata, &smithy.SerializationError{Err: err} 2118 } 2119 2120 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2121 return out, metadata, &smithy.SerializationError{Err: err} 2122 } 2123 2124 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2125 return out, metadata, &smithy.SerializationError{Err: err} 2126 } 2127 in.Request = request 2128 2129 return next.HandleSerialize(ctx, in) 2130} 2131 2132type awsAwsjson11_serializeOpListTagsForResource struct { 2133} 2134 2135func (*awsAwsjson11_serializeOpListTagsForResource) ID() string { 2136 return "OperationSerializer" 2137} 2138 2139func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2140 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2141) { 2142 request, ok := in.Request.(*smithyhttp.Request) 2143 if !ok { 2144 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2145 } 2146 2147 input, ok := in.Parameters.(*ListTagsForResourceInput) 2148 _ = input 2149 if !ok { 2150 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2151 } 2152 2153 request.Request.URL.Path = "/" 2154 request.Request.Method = "POST" 2155 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2156 if err != nil { 2157 return out, metadata, &smithy.SerializationError{Err: err} 2158 } 2159 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2160 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ListTagsForResource") 2161 2162 jsonEncoder := smithyjson.NewEncoder() 2163 if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil { 2164 return out, metadata, &smithy.SerializationError{Err: err} 2165 } 2166 2167 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2168 return out, metadata, &smithy.SerializationError{Err: err} 2169 } 2170 2171 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2172 return out, metadata, &smithy.SerializationError{Err: err} 2173 } 2174 in.Request = request 2175 2176 return next.HandleSerialize(ctx, in) 2177} 2178 2179type awsAwsjson11_serializeOpRegisterCertificate struct { 2180} 2181 2182func (*awsAwsjson11_serializeOpRegisterCertificate) ID() string { 2183 return "OperationSerializer" 2184} 2185 2186func (m *awsAwsjson11_serializeOpRegisterCertificate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2187 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2188) { 2189 request, ok := in.Request.(*smithyhttp.Request) 2190 if !ok { 2191 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2192 } 2193 2194 input, ok := in.Parameters.(*RegisterCertificateInput) 2195 _ = input 2196 if !ok { 2197 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2198 } 2199 2200 request.Request.URL.Path = "/" 2201 request.Request.Method = "POST" 2202 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2203 if err != nil { 2204 return out, metadata, &smithy.SerializationError{Err: err} 2205 } 2206 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2207 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.RegisterCertificate") 2208 2209 jsonEncoder := smithyjson.NewEncoder() 2210 if err := awsAwsjson11_serializeOpDocumentRegisterCertificateInput(input, jsonEncoder.Value); err != nil { 2211 return out, metadata, &smithy.SerializationError{Err: err} 2212 } 2213 2214 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2215 return out, metadata, &smithy.SerializationError{Err: err} 2216 } 2217 2218 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2219 return out, metadata, &smithy.SerializationError{Err: err} 2220 } 2221 in.Request = request 2222 2223 return next.HandleSerialize(ctx, in) 2224} 2225 2226type awsAwsjson11_serializeOpRegisterEventTopic struct { 2227} 2228 2229func (*awsAwsjson11_serializeOpRegisterEventTopic) ID() string { 2230 return "OperationSerializer" 2231} 2232 2233func (m *awsAwsjson11_serializeOpRegisterEventTopic) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2234 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2235) { 2236 request, ok := in.Request.(*smithyhttp.Request) 2237 if !ok { 2238 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2239 } 2240 2241 input, ok := in.Parameters.(*RegisterEventTopicInput) 2242 _ = input 2243 if !ok { 2244 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2245 } 2246 2247 request.Request.URL.Path = "/" 2248 request.Request.Method = "POST" 2249 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2250 if err != nil { 2251 return out, metadata, &smithy.SerializationError{Err: err} 2252 } 2253 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2254 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.RegisterEventTopic") 2255 2256 jsonEncoder := smithyjson.NewEncoder() 2257 if err := awsAwsjson11_serializeOpDocumentRegisterEventTopicInput(input, jsonEncoder.Value); err != nil { 2258 return out, metadata, &smithy.SerializationError{Err: err} 2259 } 2260 2261 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2262 return out, metadata, &smithy.SerializationError{Err: err} 2263 } 2264 2265 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2266 return out, metadata, &smithy.SerializationError{Err: err} 2267 } 2268 in.Request = request 2269 2270 return next.HandleSerialize(ctx, in) 2271} 2272 2273type awsAwsjson11_serializeOpRejectSharedDirectory struct { 2274} 2275 2276func (*awsAwsjson11_serializeOpRejectSharedDirectory) ID() string { 2277 return "OperationSerializer" 2278} 2279 2280func (m *awsAwsjson11_serializeOpRejectSharedDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2281 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2282) { 2283 request, ok := in.Request.(*smithyhttp.Request) 2284 if !ok { 2285 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2286 } 2287 2288 input, ok := in.Parameters.(*RejectSharedDirectoryInput) 2289 _ = input 2290 if !ok { 2291 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2292 } 2293 2294 request.Request.URL.Path = "/" 2295 request.Request.Method = "POST" 2296 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2297 if err != nil { 2298 return out, metadata, &smithy.SerializationError{Err: err} 2299 } 2300 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2301 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.RejectSharedDirectory") 2302 2303 jsonEncoder := smithyjson.NewEncoder() 2304 if err := awsAwsjson11_serializeOpDocumentRejectSharedDirectoryInput(input, jsonEncoder.Value); err != nil { 2305 return out, metadata, &smithy.SerializationError{Err: err} 2306 } 2307 2308 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2309 return out, metadata, &smithy.SerializationError{Err: err} 2310 } 2311 2312 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2313 return out, metadata, &smithy.SerializationError{Err: err} 2314 } 2315 in.Request = request 2316 2317 return next.HandleSerialize(ctx, in) 2318} 2319 2320type awsAwsjson11_serializeOpRemoveIpRoutes struct { 2321} 2322 2323func (*awsAwsjson11_serializeOpRemoveIpRoutes) ID() string { 2324 return "OperationSerializer" 2325} 2326 2327func (m *awsAwsjson11_serializeOpRemoveIpRoutes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2328 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2329) { 2330 request, ok := in.Request.(*smithyhttp.Request) 2331 if !ok { 2332 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2333 } 2334 2335 input, ok := in.Parameters.(*RemoveIpRoutesInput) 2336 _ = input 2337 if !ok { 2338 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2339 } 2340 2341 request.Request.URL.Path = "/" 2342 request.Request.Method = "POST" 2343 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2344 if err != nil { 2345 return out, metadata, &smithy.SerializationError{Err: err} 2346 } 2347 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2348 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.RemoveIpRoutes") 2349 2350 jsonEncoder := smithyjson.NewEncoder() 2351 if err := awsAwsjson11_serializeOpDocumentRemoveIpRoutesInput(input, jsonEncoder.Value); err != nil { 2352 return out, metadata, &smithy.SerializationError{Err: err} 2353 } 2354 2355 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2356 return out, metadata, &smithy.SerializationError{Err: err} 2357 } 2358 2359 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2360 return out, metadata, &smithy.SerializationError{Err: err} 2361 } 2362 in.Request = request 2363 2364 return next.HandleSerialize(ctx, in) 2365} 2366 2367type awsAwsjson11_serializeOpRemoveRegion struct { 2368} 2369 2370func (*awsAwsjson11_serializeOpRemoveRegion) ID() string { 2371 return "OperationSerializer" 2372} 2373 2374func (m *awsAwsjson11_serializeOpRemoveRegion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2375 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2376) { 2377 request, ok := in.Request.(*smithyhttp.Request) 2378 if !ok { 2379 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2380 } 2381 2382 input, ok := in.Parameters.(*RemoveRegionInput) 2383 _ = input 2384 if !ok { 2385 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2386 } 2387 2388 request.Request.URL.Path = "/" 2389 request.Request.Method = "POST" 2390 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2391 if err != nil { 2392 return out, metadata, &smithy.SerializationError{Err: err} 2393 } 2394 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2395 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.RemoveRegion") 2396 2397 jsonEncoder := smithyjson.NewEncoder() 2398 if err := awsAwsjson11_serializeOpDocumentRemoveRegionInput(input, jsonEncoder.Value); err != nil { 2399 return out, metadata, &smithy.SerializationError{Err: err} 2400 } 2401 2402 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2403 return out, metadata, &smithy.SerializationError{Err: err} 2404 } 2405 2406 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2407 return out, metadata, &smithy.SerializationError{Err: err} 2408 } 2409 in.Request = request 2410 2411 return next.HandleSerialize(ctx, in) 2412} 2413 2414type awsAwsjson11_serializeOpRemoveTagsFromResource struct { 2415} 2416 2417func (*awsAwsjson11_serializeOpRemoveTagsFromResource) ID() string { 2418 return "OperationSerializer" 2419} 2420 2421func (m *awsAwsjson11_serializeOpRemoveTagsFromResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2422 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2423) { 2424 request, ok := in.Request.(*smithyhttp.Request) 2425 if !ok { 2426 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2427 } 2428 2429 input, ok := in.Parameters.(*RemoveTagsFromResourceInput) 2430 _ = input 2431 if !ok { 2432 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2433 } 2434 2435 request.Request.URL.Path = "/" 2436 request.Request.Method = "POST" 2437 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2438 if err != nil { 2439 return out, metadata, &smithy.SerializationError{Err: err} 2440 } 2441 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2442 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.RemoveTagsFromResource") 2443 2444 jsonEncoder := smithyjson.NewEncoder() 2445 if err := awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(input, jsonEncoder.Value); err != nil { 2446 return out, metadata, &smithy.SerializationError{Err: err} 2447 } 2448 2449 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2450 return out, metadata, &smithy.SerializationError{Err: err} 2451 } 2452 2453 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2454 return out, metadata, &smithy.SerializationError{Err: err} 2455 } 2456 in.Request = request 2457 2458 return next.HandleSerialize(ctx, in) 2459} 2460 2461type awsAwsjson11_serializeOpResetUserPassword struct { 2462} 2463 2464func (*awsAwsjson11_serializeOpResetUserPassword) ID() string { 2465 return "OperationSerializer" 2466} 2467 2468func (m *awsAwsjson11_serializeOpResetUserPassword) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2469 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2470) { 2471 request, ok := in.Request.(*smithyhttp.Request) 2472 if !ok { 2473 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2474 } 2475 2476 input, ok := in.Parameters.(*ResetUserPasswordInput) 2477 _ = input 2478 if !ok { 2479 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2480 } 2481 2482 request.Request.URL.Path = "/" 2483 request.Request.Method = "POST" 2484 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2485 if err != nil { 2486 return out, metadata, &smithy.SerializationError{Err: err} 2487 } 2488 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2489 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ResetUserPassword") 2490 2491 jsonEncoder := smithyjson.NewEncoder() 2492 if err := awsAwsjson11_serializeOpDocumentResetUserPasswordInput(input, jsonEncoder.Value); err != nil { 2493 return out, metadata, &smithy.SerializationError{Err: err} 2494 } 2495 2496 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2497 return out, metadata, &smithy.SerializationError{Err: err} 2498 } 2499 2500 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2501 return out, metadata, &smithy.SerializationError{Err: err} 2502 } 2503 in.Request = request 2504 2505 return next.HandleSerialize(ctx, in) 2506} 2507 2508type awsAwsjson11_serializeOpRestoreFromSnapshot struct { 2509} 2510 2511func (*awsAwsjson11_serializeOpRestoreFromSnapshot) ID() string { 2512 return "OperationSerializer" 2513} 2514 2515func (m *awsAwsjson11_serializeOpRestoreFromSnapshot) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2516 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2517) { 2518 request, ok := in.Request.(*smithyhttp.Request) 2519 if !ok { 2520 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2521 } 2522 2523 input, ok := in.Parameters.(*RestoreFromSnapshotInput) 2524 _ = input 2525 if !ok { 2526 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2527 } 2528 2529 request.Request.URL.Path = "/" 2530 request.Request.Method = "POST" 2531 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2532 if err != nil { 2533 return out, metadata, &smithy.SerializationError{Err: err} 2534 } 2535 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2536 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.RestoreFromSnapshot") 2537 2538 jsonEncoder := smithyjson.NewEncoder() 2539 if err := awsAwsjson11_serializeOpDocumentRestoreFromSnapshotInput(input, jsonEncoder.Value); err != nil { 2540 return out, metadata, &smithy.SerializationError{Err: err} 2541 } 2542 2543 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2544 return out, metadata, &smithy.SerializationError{Err: err} 2545 } 2546 2547 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2548 return out, metadata, &smithy.SerializationError{Err: err} 2549 } 2550 in.Request = request 2551 2552 return next.HandleSerialize(ctx, in) 2553} 2554 2555type awsAwsjson11_serializeOpShareDirectory struct { 2556} 2557 2558func (*awsAwsjson11_serializeOpShareDirectory) ID() string { 2559 return "OperationSerializer" 2560} 2561 2562func (m *awsAwsjson11_serializeOpShareDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2563 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2564) { 2565 request, ok := in.Request.(*smithyhttp.Request) 2566 if !ok { 2567 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2568 } 2569 2570 input, ok := in.Parameters.(*ShareDirectoryInput) 2571 _ = input 2572 if !ok { 2573 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2574 } 2575 2576 request.Request.URL.Path = "/" 2577 request.Request.Method = "POST" 2578 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2579 if err != nil { 2580 return out, metadata, &smithy.SerializationError{Err: err} 2581 } 2582 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2583 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.ShareDirectory") 2584 2585 jsonEncoder := smithyjson.NewEncoder() 2586 if err := awsAwsjson11_serializeOpDocumentShareDirectoryInput(input, jsonEncoder.Value); err != nil { 2587 return out, metadata, &smithy.SerializationError{Err: err} 2588 } 2589 2590 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2591 return out, metadata, &smithy.SerializationError{Err: err} 2592 } 2593 2594 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2595 return out, metadata, &smithy.SerializationError{Err: err} 2596 } 2597 in.Request = request 2598 2599 return next.HandleSerialize(ctx, in) 2600} 2601 2602type awsAwsjson11_serializeOpStartSchemaExtension struct { 2603} 2604 2605func (*awsAwsjson11_serializeOpStartSchemaExtension) ID() string { 2606 return "OperationSerializer" 2607} 2608 2609func (m *awsAwsjson11_serializeOpStartSchemaExtension) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2610 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2611) { 2612 request, ok := in.Request.(*smithyhttp.Request) 2613 if !ok { 2614 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2615 } 2616 2617 input, ok := in.Parameters.(*StartSchemaExtensionInput) 2618 _ = input 2619 if !ok { 2620 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2621 } 2622 2623 request.Request.URL.Path = "/" 2624 request.Request.Method = "POST" 2625 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2626 if err != nil { 2627 return out, metadata, &smithy.SerializationError{Err: err} 2628 } 2629 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2630 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.StartSchemaExtension") 2631 2632 jsonEncoder := smithyjson.NewEncoder() 2633 if err := awsAwsjson11_serializeOpDocumentStartSchemaExtensionInput(input, jsonEncoder.Value); err != nil { 2634 return out, metadata, &smithy.SerializationError{Err: err} 2635 } 2636 2637 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2638 return out, metadata, &smithy.SerializationError{Err: err} 2639 } 2640 2641 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2642 return out, metadata, &smithy.SerializationError{Err: err} 2643 } 2644 in.Request = request 2645 2646 return next.HandleSerialize(ctx, in) 2647} 2648 2649type awsAwsjson11_serializeOpUnshareDirectory struct { 2650} 2651 2652func (*awsAwsjson11_serializeOpUnshareDirectory) ID() string { 2653 return "OperationSerializer" 2654} 2655 2656func (m *awsAwsjson11_serializeOpUnshareDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2657 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2658) { 2659 request, ok := in.Request.(*smithyhttp.Request) 2660 if !ok { 2661 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2662 } 2663 2664 input, ok := in.Parameters.(*UnshareDirectoryInput) 2665 _ = input 2666 if !ok { 2667 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2668 } 2669 2670 request.Request.URL.Path = "/" 2671 request.Request.Method = "POST" 2672 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2673 if err != nil { 2674 return out, metadata, &smithy.SerializationError{Err: err} 2675 } 2676 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2677 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UnshareDirectory") 2678 2679 jsonEncoder := smithyjson.NewEncoder() 2680 if err := awsAwsjson11_serializeOpDocumentUnshareDirectoryInput(input, jsonEncoder.Value); err != nil { 2681 return out, metadata, &smithy.SerializationError{Err: err} 2682 } 2683 2684 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2685 return out, metadata, &smithy.SerializationError{Err: err} 2686 } 2687 2688 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2689 return out, metadata, &smithy.SerializationError{Err: err} 2690 } 2691 in.Request = request 2692 2693 return next.HandleSerialize(ctx, in) 2694} 2695 2696type awsAwsjson11_serializeOpUpdateConditionalForwarder struct { 2697} 2698 2699func (*awsAwsjson11_serializeOpUpdateConditionalForwarder) ID() string { 2700 return "OperationSerializer" 2701} 2702 2703func (m *awsAwsjson11_serializeOpUpdateConditionalForwarder) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2704 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2705) { 2706 request, ok := in.Request.(*smithyhttp.Request) 2707 if !ok { 2708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2709 } 2710 2711 input, ok := in.Parameters.(*UpdateConditionalForwarderInput) 2712 _ = input 2713 if !ok { 2714 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2715 } 2716 2717 request.Request.URL.Path = "/" 2718 request.Request.Method = "POST" 2719 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2720 if err != nil { 2721 return out, metadata, &smithy.SerializationError{Err: err} 2722 } 2723 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2724 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateConditionalForwarder") 2725 2726 jsonEncoder := smithyjson.NewEncoder() 2727 if err := awsAwsjson11_serializeOpDocumentUpdateConditionalForwarderInput(input, jsonEncoder.Value); err != nil { 2728 return out, metadata, &smithy.SerializationError{Err: err} 2729 } 2730 2731 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2732 return out, metadata, &smithy.SerializationError{Err: err} 2733 } 2734 2735 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2736 return out, metadata, &smithy.SerializationError{Err: err} 2737 } 2738 in.Request = request 2739 2740 return next.HandleSerialize(ctx, in) 2741} 2742 2743type awsAwsjson11_serializeOpUpdateNumberOfDomainControllers struct { 2744} 2745 2746func (*awsAwsjson11_serializeOpUpdateNumberOfDomainControllers) ID() string { 2747 return "OperationSerializer" 2748} 2749 2750func (m *awsAwsjson11_serializeOpUpdateNumberOfDomainControllers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2751 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2752) { 2753 request, ok := in.Request.(*smithyhttp.Request) 2754 if !ok { 2755 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2756 } 2757 2758 input, ok := in.Parameters.(*UpdateNumberOfDomainControllersInput) 2759 _ = input 2760 if !ok { 2761 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2762 } 2763 2764 request.Request.URL.Path = "/" 2765 request.Request.Method = "POST" 2766 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2767 if err != nil { 2768 return out, metadata, &smithy.SerializationError{Err: err} 2769 } 2770 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2771 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateNumberOfDomainControllers") 2772 2773 jsonEncoder := smithyjson.NewEncoder() 2774 if err := awsAwsjson11_serializeOpDocumentUpdateNumberOfDomainControllersInput(input, jsonEncoder.Value); err != nil { 2775 return out, metadata, &smithy.SerializationError{Err: err} 2776 } 2777 2778 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2779 return out, metadata, &smithy.SerializationError{Err: err} 2780 } 2781 2782 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2783 return out, metadata, &smithy.SerializationError{Err: err} 2784 } 2785 in.Request = request 2786 2787 return next.HandleSerialize(ctx, in) 2788} 2789 2790type awsAwsjson11_serializeOpUpdateRadius struct { 2791} 2792 2793func (*awsAwsjson11_serializeOpUpdateRadius) ID() string { 2794 return "OperationSerializer" 2795} 2796 2797func (m *awsAwsjson11_serializeOpUpdateRadius) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2798 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2799) { 2800 request, ok := in.Request.(*smithyhttp.Request) 2801 if !ok { 2802 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2803 } 2804 2805 input, ok := in.Parameters.(*UpdateRadiusInput) 2806 _ = input 2807 if !ok { 2808 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2809 } 2810 2811 request.Request.URL.Path = "/" 2812 request.Request.Method = "POST" 2813 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2814 if err != nil { 2815 return out, metadata, &smithy.SerializationError{Err: err} 2816 } 2817 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2818 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateRadius") 2819 2820 jsonEncoder := smithyjson.NewEncoder() 2821 if err := awsAwsjson11_serializeOpDocumentUpdateRadiusInput(input, jsonEncoder.Value); err != nil { 2822 return out, metadata, &smithy.SerializationError{Err: err} 2823 } 2824 2825 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2826 return out, metadata, &smithy.SerializationError{Err: err} 2827 } 2828 2829 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2830 return out, metadata, &smithy.SerializationError{Err: err} 2831 } 2832 in.Request = request 2833 2834 return next.HandleSerialize(ctx, in) 2835} 2836 2837type awsAwsjson11_serializeOpUpdateTrust struct { 2838} 2839 2840func (*awsAwsjson11_serializeOpUpdateTrust) ID() string { 2841 return "OperationSerializer" 2842} 2843 2844func (m *awsAwsjson11_serializeOpUpdateTrust) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2845 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2846) { 2847 request, ok := in.Request.(*smithyhttp.Request) 2848 if !ok { 2849 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2850 } 2851 2852 input, ok := in.Parameters.(*UpdateTrustInput) 2853 _ = input 2854 if !ok { 2855 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2856 } 2857 2858 request.Request.URL.Path = "/" 2859 request.Request.Method = "POST" 2860 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2861 if err != nil { 2862 return out, metadata, &smithy.SerializationError{Err: err} 2863 } 2864 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2865 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.UpdateTrust") 2866 2867 jsonEncoder := smithyjson.NewEncoder() 2868 if err := awsAwsjson11_serializeOpDocumentUpdateTrustInput(input, jsonEncoder.Value); err != nil { 2869 return out, metadata, &smithy.SerializationError{Err: err} 2870 } 2871 2872 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2873 return out, metadata, &smithy.SerializationError{Err: err} 2874 } 2875 2876 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2877 return out, metadata, &smithy.SerializationError{Err: err} 2878 } 2879 in.Request = request 2880 2881 return next.HandleSerialize(ctx, in) 2882} 2883 2884type awsAwsjson11_serializeOpVerifyTrust struct { 2885} 2886 2887func (*awsAwsjson11_serializeOpVerifyTrust) ID() string { 2888 return "OperationSerializer" 2889} 2890 2891func (m *awsAwsjson11_serializeOpVerifyTrust) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2892 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2893) { 2894 request, ok := in.Request.(*smithyhttp.Request) 2895 if !ok { 2896 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2897 } 2898 2899 input, ok := in.Parameters.(*VerifyTrustInput) 2900 _ = input 2901 if !ok { 2902 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2903 } 2904 2905 request.Request.URL.Path = "/" 2906 request.Request.Method = "POST" 2907 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2908 if err != nil { 2909 return out, metadata, &smithy.SerializationError{Err: err} 2910 } 2911 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2912 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.VerifyTrust") 2913 2914 jsonEncoder := smithyjson.NewEncoder() 2915 if err := awsAwsjson11_serializeOpDocumentVerifyTrustInput(input, jsonEncoder.Value); err != nil { 2916 return out, metadata, &smithy.SerializationError{Err: err} 2917 } 2918 2919 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2920 return out, metadata, &smithy.SerializationError{Err: err} 2921 } 2922 2923 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2924 return out, metadata, &smithy.SerializationError{Err: err} 2925 } 2926 in.Request = request 2927 2928 return next.HandleSerialize(ctx, in) 2929} 2930func awsAwsjson11_serializeDocumentAttribute(v *types.Attribute, value smithyjson.Value) error { 2931 object := value.Object() 2932 defer object.Close() 2933 2934 if v.Name != nil { 2935 ok := object.Key("Name") 2936 ok.String(*v.Name) 2937 } 2938 2939 if v.Value != nil { 2940 ok := object.Key("Value") 2941 ok.String(*v.Value) 2942 } 2943 2944 return nil 2945} 2946 2947func awsAwsjson11_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error { 2948 array := value.Array() 2949 defer array.Close() 2950 2951 for i := range v { 2952 av := array.Value() 2953 if err := awsAwsjson11_serializeDocumentAttribute(&v[i], av); err != nil { 2954 return err 2955 } 2956 } 2957 return nil 2958} 2959 2960func awsAwsjson11_serializeDocumentCidrIps(v []string, value smithyjson.Value) error { 2961 array := value.Array() 2962 defer array.Close() 2963 2964 for i := range v { 2965 av := array.Value() 2966 av.String(v[i]) 2967 } 2968 return nil 2969} 2970 2971func awsAwsjson11_serializeDocumentClientCertAuthSettings(v *types.ClientCertAuthSettings, value smithyjson.Value) error { 2972 object := value.Object() 2973 defer object.Close() 2974 2975 if v.OCSPUrl != nil { 2976 ok := object.Key("OCSPUrl") 2977 ok.String(*v.OCSPUrl) 2978 } 2979 2980 return nil 2981} 2982 2983func awsAwsjson11_serializeDocumentDirectoryConnectSettings(v *types.DirectoryConnectSettings, value smithyjson.Value) error { 2984 object := value.Object() 2985 defer object.Close() 2986 2987 if v.CustomerDnsIps != nil { 2988 ok := object.Key("CustomerDnsIps") 2989 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.CustomerDnsIps, ok); err != nil { 2990 return err 2991 } 2992 } 2993 2994 if v.CustomerUserName != nil { 2995 ok := object.Key("CustomerUserName") 2996 ok.String(*v.CustomerUserName) 2997 } 2998 2999 if v.SubnetIds != nil { 3000 ok := object.Key("SubnetIds") 3001 if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil { 3002 return err 3003 } 3004 } 3005 3006 if v.VpcId != nil { 3007 ok := object.Key("VpcId") 3008 ok.String(*v.VpcId) 3009 } 3010 3011 return nil 3012} 3013 3014func awsAwsjson11_serializeDocumentDirectoryIds(v []string, value smithyjson.Value) error { 3015 array := value.Array() 3016 defer array.Close() 3017 3018 for i := range v { 3019 av := array.Value() 3020 av.String(v[i]) 3021 } 3022 return nil 3023} 3024 3025func awsAwsjson11_serializeDocumentDirectoryVpcSettings(v *types.DirectoryVpcSettings, value smithyjson.Value) error { 3026 object := value.Object() 3027 defer object.Close() 3028 3029 if v.SubnetIds != nil { 3030 ok := object.Key("SubnetIds") 3031 if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil { 3032 return err 3033 } 3034 } 3035 3036 if v.VpcId != nil { 3037 ok := object.Key("VpcId") 3038 ok.String(*v.VpcId) 3039 } 3040 3041 return nil 3042} 3043 3044func awsAwsjson11_serializeDocumentDnsIpAddrs(v []string, value smithyjson.Value) error { 3045 array := value.Array() 3046 defer array.Close() 3047 3048 for i := range v { 3049 av := array.Value() 3050 av.String(v[i]) 3051 } 3052 return nil 3053} 3054 3055func awsAwsjson11_serializeDocumentDomainControllerIds(v []string, value smithyjson.Value) error { 3056 array := value.Array() 3057 defer array.Close() 3058 3059 for i := range v { 3060 av := array.Value() 3061 av.String(v[i]) 3062 } 3063 return nil 3064} 3065 3066func awsAwsjson11_serializeDocumentIpRoute(v *types.IpRoute, value smithyjson.Value) error { 3067 object := value.Object() 3068 defer object.Close() 3069 3070 if v.CidrIp != nil { 3071 ok := object.Key("CidrIp") 3072 ok.String(*v.CidrIp) 3073 } 3074 3075 if v.Description != nil { 3076 ok := object.Key("Description") 3077 ok.String(*v.Description) 3078 } 3079 3080 return nil 3081} 3082 3083func awsAwsjson11_serializeDocumentIpRoutes(v []types.IpRoute, value smithyjson.Value) error { 3084 array := value.Array() 3085 defer array.Close() 3086 3087 for i := range v { 3088 av := array.Value() 3089 if err := awsAwsjson11_serializeDocumentIpRoute(&v[i], av); err != nil { 3090 return err 3091 } 3092 } 3093 return nil 3094} 3095 3096func awsAwsjson11_serializeDocumentRadiusSettings(v *types.RadiusSettings, value smithyjson.Value) error { 3097 object := value.Object() 3098 defer object.Close() 3099 3100 if len(v.AuthenticationProtocol) > 0 { 3101 ok := object.Key("AuthenticationProtocol") 3102 ok.String(string(v.AuthenticationProtocol)) 3103 } 3104 3105 if v.DisplayLabel != nil { 3106 ok := object.Key("DisplayLabel") 3107 ok.String(*v.DisplayLabel) 3108 } 3109 3110 if v.RadiusPort != 0 { 3111 ok := object.Key("RadiusPort") 3112 ok.Integer(v.RadiusPort) 3113 } 3114 3115 if v.RadiusRetries != 0 { 3116 ok := object.Key("RadiusRetries") 3117 ok.Integer(v.RadiusRetries) 3118 } 3119 3120 if v.RadiusServers != nil { 3121 ok := object.Key("RadiusServers") 3122 if err := awsAwsjson11_serializeDocumentServers(v.RadiusServers, ok); err != nil { 3123 return err 3124 } 3125 } 3126 3127 if v.RadiusTimeout != 0 { 3128 ok := object.Key("RadiusTimeout") 3129 ok.Integer(v.RadiusTimeout) 3130 } 3131 3132 if v.SharedSecret != nil { 3133 ok := object.Key("SharedSecret") 3134 ok.String(*v.SharedSecret) 3135 } 3136 3137 if v.UseSameUsername { 3138 ok := object.Key("UseSameUsername") 3139 ok.Boolean(v.UseSameUsername) 3140 } 3141 3142 return nil 3143} 3144 3145func awsAwsjson11_serializeDocumentRemoteDomainNames(v []string, value smithyjson.Value) error { 3146 array := value.Array() 3147 defer array.Close() 3148 3149 for i := range v { 3150 av := array.Value() 3151 av.String(v[i]) 3152 } 3153 return nil 3154} 3155 3156func awsAwsjson11_serializeDocumentServers(v []string, value smithyjson.Value) error { 3157 array := value.Array() 3158 defer array.Close() 3159 3160 for i := range v { 3161 av := array.Value() 3162 av.String(v[i]) 3163 } 3164 return nil 3165} 3166 3167func awsAwsjson11_serializeDocumentShareTarget(v *types.ShareTarget, value smithyjson.Value) error { 3168 object := value.Object() 3169 defer object.Close() 3170 3171 if v.Id != nil { 3172 ok := object.Key("Id") 3173 ok.String(*v.Id) 3174 } 3175 3176 if len(v.Type) > 0 { 3177 ok := object.Key("Type") 3178 ok.String(string(v.Type)) 3179 } 3180 3181 return nil 3182} 3183 3184func awsAwsjson11_serializeDocumentSnapshotIds(v []string, value smithyjson.Value) error { 3185 array := value.Array() 3186 defer array.Close() 3187 3188 for i := range v { 3189 av := array.Value() 3190 av.String(v[i]) 3191 } 3192 return nil 3193} 3194 3195func awsAwsjson11_serializeDocumentSubnetIds(v []string, value smithyjson.Value) error { 3196 array := value.Array() 3197 defer array.Close() 3198 3199 for i := range v { 3200 av := array.Value() 3201 av.String(v[i]) 3202 } 3203 return nil 3204} 3205 3206func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 3207 object := value.Object() 3208 defer object.Close() 3209 3210 if v.Key != nil { 3211 ok := object.Key("Key") 3212 ok.String(*v.Key) 3213 } 3214 3215 if v.Value != nil { 3216 ok := object.Key("Value") 3217 ok.String(*v.Value) 3218 } 3219 3220 return nil 3221} 3222 3223func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error { 3224 array := value.Array() 3225 defer array.Close() 3226 3227 for i := range v { 3228 av := array.Value() 3229 av.String(v[i]) 3230 } 3231 return nil 3232} 3233 3234func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error { 3235 array := value.Array() 3236 defer array.Close() 3237 3238 for i := range v { 3239 av := array.Value() 3240 if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil { 3241 return err 3242 } 3243 } 3244 return nil 3245} 3246 3247func awsAwsjson11_serializeDocumentTopicNames(v []string, value smithyjson.Value) error { 3248 array := value.Array() 3249 defer array.Close() 3250 3251 for i := range v { 3252 av := array.Value() 3253 av.String(v[i]) 3254 } 3255 return nil 3256} 3257 3258func awsAwsjson11_serializeDocumentTrustIds(v []string, value smithyjson.Value) error { 3259 array := value.Array() 3260 defer array.Close() 3261 3262 for i := range v { 3263 av := array.Value() 3264 av.String(v[i]) 3265 } 3266 return nil 3267} 3268 3269func awsAwsjson11_serializeDocumentUnshareTarget(v *types.UnshareTarget, value smithyjson.Value) error { 3270 object := value.Object() 3271 defer object.Close() 3272 3273 if v.Id != nil { 3274 ok := object.Key("Id") 3275 ok.String(*v.Id) 3276 } 3277 3278 if len(v.Type) > 0 { 3279 ok := object.Key("Type") 3280 ok.String(string(v.Type)) 3281 } 3282 3283 return nil 3284} 3285 3286func awsAwsjson11_serializeOpDocumentAcceptSharedDirectoryInput(v *AcceptSharedDirectoryInput, value smithyjson.Value) error { 3287 object := value.Object() 3288 defer object.Close() 3289 3290 if v.SharedDirectoryId != nil { 3291 ok := object.Key("SharedDirectoryId") 3292 ok.String(*v.SharedDirectoryId) 3293 } 3294 3295 return nil 3296} 3297 3298func awsAwsjson11_serializeOpDocumentAddIpRoutesInput(v *AddIpRoutesInput, value smithyjson.Value) error { 3299 object := value.Object() 3300 defer object.Close() 3301 3302 if v.DirectoryId != nil { 3303 ok := object.Key("DirectoryId") 3304 ok.String(*v.DirectoryId) 3305 } 3306 3307 if v.IpRoutes != nil { 3308 ok := object.Key("IpRoutes") 3309 if err := awsAwsjson11_serializeDocumentIpRoutes(v.IpRoutes, ok); err != nil { 3310 return err 3311 } 3312 } 3313 3314 if v.UpdateSecurityGroupForDirectoryControllers { 3315 ok := object.Key("UpdateSecurityGroupForDirectoryControllers") 3316 ok.Boolean(v.UpdateSecurityGroupForDirectoryControllers) 3317 } 3318 3319 return nil 3320} 3321 3322func awsAwsjson11_serializeOpDocumentAddRegionInput(v *AddRegionInput, value smithyjson.Value) error { 3323 object := value.Object() 3324 defer object.Close() 3325 3326 if v.DirectoryId != nil { 3327 ok := object.Key("DirectoryId") 3328 ok.String(*v.DirectoryId) 3329 } 3330 3331 if v.RegionName != nil { 3332 ok := object.Key("RegionName") 3333 ok.String(*v.RegionName) 3334 } 3335 3336 if v.VPCSettings != nil { 3337 ok := object.Key("VPCSettings") 3338 if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VPCSettings, ok); err != nil { 3339 return err 3340 } 3341 } 3342 3343 return nil 3344} 3345 3346func awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(v *AddTagsToResourceInput, value smithyjson.Value) error { 3347 object := value.Object() 3348 defer object.Close() 3349 3350 if v.ResourceId != nil { 3351 ok := object.Key("ResourceId") 3352 ok.String(*v.ResourceId) 3353 } 3354 3355 if v.Tags != nil { 3356 ok := object.Key("Tags") 3357 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3358 return err 3359 } 3360 } 3361 3362 return nil 3363} 3364 3365func awsAwsjson11_serializeOpDocumentCancelSchemaExtensionInput(v *CancelSchemaExtensionInput, value smithyjson.Value) error { 3366 object := value.Object() 3367 defer object.Close() 3368 3369 if v.DirectoryId != nil { 3370 ok := object.Key("DirectoryId") 3371 ok.String(*v.DirectoryId) 3372 } 3373 3374 if v.SchemaExtensionId != nil { 3375 ok := object.Key("SchemaExtensionId") 3376 ok.String(*v.SchemaExtensionId) 3377 } 3378 3379 return nil 3380} 3381 3382func awsAwsjson11_serializeOpDocumentConnectDirectoryInput(v *ConnectDirectoryInput, value smithyjson.Value) error { 3383 object := value.Object() 3384 defer object.Close() 3385 3386 if v.ConnectSettings != nil { 3387 ok := object.Key("ConnectSettings") 3388 if err := awsAwsjson11_serializeDocumentDirectoryConnectSettings(v.ConnectSettings, ok); err != nil { 3389 return err 3390 } 3391 } 3392 3393 if v.Description != nil { 3394 ok := object.Key("Description") 3395 ok.String(*v.Description) 3396 } 3397 3398 if v.Name != nil { 3399 ok := object.Key("Name") 3400 ok.String(*v.Name) 3401 } 3402 3403 if v.Password != nil { 3404 ok := object.Key("Password") 3405 ok.String(*v.Password) 3406 } 3407 3408 if v.ShortName != nil { 3409 ok := object.Key("ShortName") 3410 ok.String(*v.ShortName) 3411 } 3412 3413 if len(v.Size) > 0 { 3414 ok := object.Key("Size") 3415 ok.String(string(v.Size)) 3416 } 3417 3418 if v.Tags != nil { 3419 ok := object.Key("Tags") 3420 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3421 return err 3422 } 3423 } 3424 3425 return nil 3426} 3427 3428func awsAwsjson11_serializeOpDocumentCreateAliasInput(v *CreateAliasInput, value smithyjson.Value) error { 3429 object := value.Object() 3430 defer object.Close() 3431 3432 if v.Alias != nil { 3433 ok := object.Key("Alias") 3434 ok.String(*v.Alias) 3435 } 3436 3437 if v.DirectoryId != nil { 3438 ok := object.Key("DirectoryId") 3439 ok.String(*v.DirectoryId) 3440 } 3441 3442 return nil 3443} 3444 3445func awsAwsjson11_serializeOpDocumentCreateComputerInput(v *CreateComputerInput, value smithyjson.Value) error { 3446 object := value.Object() 3447 defer object.Close() 3448 3449 if v.ComputerAttributes != nil { 3450 ok := object.Key("ComputerAttributes") 3451 if err := awsAwsjson11_serializeDocumentAttributes(v.ComputerAttributes, ok); err != nil { 3452 return err 3453 } 3454 } 3455 3456 if v.ComputerName != nil { 3457 ok := object.Key("ComputerName") 3458 ok.String(*v.ComputerName) 3459 } 3460 3461 if v.DirectoryId != nil { 3462 ok := object.Key("DirectoryId") 3463 ok.String(*v.DirectoryId) 3464 } 3465 3466 if v.OrganizationalUnitDistinguishedName != nil { 3467 ok := object.Key("OrganizationalUnitDistinguishedName") 3468 ok.String(*v.OrganizationalUnitDistinguishedName) 3469 } 3470 3471 if v.Password != nil { 3472 ok := object.Key("Password") 3473 ok.String(*v.Password) 3474 } 3475 3476 return nil 3477} 3478 3479func awsAwsjson11_serializeOpDocumentCreateConditionalForwarderInput(v *CreateConditionalForwarderInput, value smithyjson.Value) error { 3480 object := value.Object() 3481 defer object.Close() 3482 3483 if v.DirectoryId != nil { 3484 ok := object.Key("DirectoryId") 3485 ok.String(*v.DirectoryId) 3486 } 3487 3488 if v.DnsIpAddrs != nil { 3489 ok := object.Key("DnsIpAddrs") 3490 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.DnsIpAddrs, ok); err != nil { 3491 return err 3492 } 3493 } 3494 3495 if v.RemoteDomainName != nil { 3496 ok := object.Key("RemoteDomainName") 3497 ok.String(*v.RemoteDomainName) 3498 } 3499 3500 return nil 3501} 3502 3503func awsAwsjson11_serializeOpDocumentCreateDirectoryInput(v *CreateDirectoryInput, value smithyjson.Value) error { 3504 object := value.Object() 3505 defer object.Close() 3506 3507 if v.Description != nil { 3508 ok := object.Key("Description") 3509 ok.String(*v.Description) 3510 } 3511 3512 if v.Name != nil { 3513 ok := object.Key("Name") 3514 ok.String(*v.Name) 3515 } 3516 3517 if v.Password != nil { 3518 ok := object.Key("Password") 3519 ok.String(*v.Password) 3520 } 3521 3522 if v.ShortName != nil { 3523 ok := object.Key("ShortName") 3524 ok.String(*v.ShortName) 3525 } 3526 3527 if len(v.Size) > 0 { 3528 ok := object.Key("Size") 3529 ok.String(string(v.Size)) 3530 } 3531 3532 if v.Tags != nil { 3533 ok := object.Key("Tags") 3534 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3535 return err 3536 } 3537 } 3538 3539 if v.VpcSettings != nil { 3540 ok := object.Key("VpcSettings") 3541 if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VpcSettings, ok); err != nil { 3542 return err 3543 } 3544 } 3545 3546 return nil 3547} 3548 3549func awsAwsjson11_serializeOpDocumentCreateLogSubscriptionInput(v *CreateLogSubscriptionInput, value smithyjson.Value) error { 3550 object := value.Object() 3551 defer object.Close() 3552 3553 if v.DirectoryId != nil { 3554 ok := object.Key("DirectoryId") 3555 ok.String(*v.DirectoryId) 3556 } 3557 3558 if v.LogGroupName != nil { 3559 ok := object.Key("LogGroupName") 3560 ok.String(*v.LogGroupName) 3561 } 3562 3563 return nil 3564} 3565 3566func awsAwsjson11_serializeOpDocumentCreateMicrosoftADInput(v *CreateMicrosoftADInput, value smithyjson.Value) error { 3567 object := value.Object() 3568 defer object.Close() 3569 3570 if v.Description != nil { 3571 ok := object.Key("Description") 3572 ok.String(*v.Description) 3573 } 3574 3575 if len(v.Edition) > 0 { 3576 ok := object.Key("Edition") 3577 ok.String(string(v.Edition)) 3578 } 3579 3580 if v.Name != nil { 3581 ok := object.Key("Name") 3582 ok.String(*v.Name) 3583 } 3584 3585 if v.Password != nil { 3586 ok := object.Key("Password") 3587 ok.String(*v.Password) 3588 } 3589 3590 if v.ShortName != nil { 3591 ok := object.Key("ShortName") 3592 ok.String(*v.ShortName) 3593 } 3594 3595 if v.Tags != nil { 3596 ok := object.Key("Tags") 3597 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3598 return err 3599 } 3600 } 3601 3602 if v.VpcSettings != nil { 3603 ok := object.Key("VpcSettings") 3604 if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VpcSettings, ok); err != nil { 3605 return err 3606 } 3607 } 3608 3609 return nil 3610} 3611 3612func awsAwsjson11_serializeOpDocumentCreateSnapshotInput(v *CreateSnapshotInput, value smithyjson.Value) error { 3613 object := value.Object() 3614 defer object.Close() 3615 3616 if v.DirectoryId != nil { 3617 ok := object.Key("DirectoryId") 3618 ok.String(*v.DirectoryId) 3619 } 3620 3621 if v.Name != nil { 3622 ok := object.Key("Name") 3623 ok.String(*v.Name) 3624 } 3625 3626 return nil 3627} 3628 3629func awsAwsjson11_serializeOpDocumentCreateTrustInput(v *CreateTrustInput, value smithyjson.Value) error { 3630 object := value.Object() 3631 defer object.Close() 3632 3633 if v.ConditionalForwarderIpAddrs != nil { 3634 ok := object.Key("ConditionalForwarderIpAddrs") 3635 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.ConditionalForwarderIpAddrs, ok); err != nil { 3636 return err 3637 } 3638 } 3639 3640 if v.DirectoryId != nil { 3641 ok := object.Key("DirectoryId") 3642 ok.String(*v.DirectoryId) 3643 } 3644 3645 if v.RemoteDomainName != nil { 3646 ok := object.Key("RemoteDomainName") 3647 ok.String(*v.RemoteDomainName) 3648 } 3649 3650 if len(v.SelectiveAuth) > 0 { 3651 ok := object.Key("SelectiveAuth") 3652 ok.String(string(v.SelectiveAuth)) 3653 } 3654 3655 if len(v.TrustDirection) > 0 { 3656 ok := object.Key("TrustDirection") 3657 ok.String(string(v.TrustDirection)) 3658 } 3659 3660 if v.TrustPassword != nil { 3661 ok := object.Key("TrustPassword") 3662 ok.String(*v.TrustPassword) 3663 } 3664 3665 if len(v.TrustType) > 0 { 3666 ok := object.Key("TrustType") 3667 ok.String(string(v.TrustType)) 3668 } 3669 3670 return nil 3671} 3672 3673func awsAwsjson11_serializeOpDocumentDeleteConditionalForwarderInput(v *DeleteConditionalForwarderInput, value smithyjson.Value) error { 3674 object := value.Object() 3675 defer object.Close() 3676 3677 if v.DirectoryId != nil { 3678 ok := object.Key("DirectoryId") 3679 ok.String(*v.DirectoryId) 3680 } 3681 3682 if v.RemoteDomainName != nil { 3683 ok := object.Key("RemoteDomainName") 3684 ok.String(*v.RemoteDomainName) 3685 } 3686 3687 return nil 3688} 3689 3690func awsAwsjson11_serializeOpDocumentDeleteDirectoryInput(v *DeleteDirectoryInput, value smithyjson.Value) error { 3691 object := value.Object() 3692 defer object.Close() 3693 3694 if v.DirectoryId != nil { 3695 ok := object.Key("DirectoryId") 3696 ok.String(*v.DirectoryId) 3697 } 3698 3699 return nil 3700} 3701 3702func awsAwsjson11_serializeOpDocumentDeleteLogSubscriptionInput(v *DeleteLogSubscriptionInput, value smithyjson.Value) error { 3703 object := value.Object() 3704 defer object.Close() 3705 3706 if v.DirectoryId != nil { 3707 ok := object.Key("DirectoryId") 3708 ok.String(*v.DirectoryId) 3709 } 3710 3711 return nil 3712} 3713 3714func awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(v *DeleteSnapshotInput, value smithyjson.Value) error { 3715 object := value.Object() 3716 defer object.Close() 3717 3718 if v.SnapshotId != nil { 3719 ok := object.Key("SnapshotId") 3720 ok.String(*v.SnapshotId) 3721 } 3722 3723 return nil 3724} 3725 3726func awsAwsjson11_serializeOpDocumentDeleteTrustInput(v *DeleteTrustInput, value smithyjson.Value) error { 3727 object := value.Object() 3728 defer object.Close() 3729 3730 if v.DeleteAssociatedConditionalForwarder { 3731 ok := object.Key("DeleteAssociatedConditionalForwarder") 3732 ok.Boolean(v.DeleteAssociatedConditionalForwarder) 3733 } 3734 3735 if v.TrustId != nil { 3736 ok := object.Key("TrustId") 3737 ok.String(*v.TrustId) 3738 } 3739 3740 return nil 3741} 3742 3743func awsAwsjson11_serializeOpDocumentDeregisterCertificateInput(v *DeregisterCertificateInput, value smithyjson.Value) error { 3744 object := value.Object() 3745 defer object.Close() 3746 3747 if v.CertificateId != nil { 3748 ok := object.Key("CertificateId") 3749 ok.String(*v.CertificateId) 3750 } 3751 3752 if v.DirectoryId != nil { 3753 ok := object.Key("DirectoryId") 3754 ok.String(*v.DirectoryId) 3755 } 3756 3757 return nil 3758} 3759 3760func awsAwsjson11_serializeOpDocumentDeregisterEventTopicInput(v *DeregisterEventTopicInput, value smithyjson.Value) error { 3761 object := value.Object() 3762 defer object.Close() 3763 3764 if v.DirectoryId != nil { 3765 ok := object.Key("DirectoryId") 3766 ok.String(*v.DirectoryId) 3767 } 3768 3769 if v.TopicName != nil { 3770 ok := object.Key("TopicName") 3771 ok.String(*v.TopicName) 3772 } 3773 3774 return nil 3775} 3776 3777func awsAwsjson11_serializeOpDocumentDescribeCertificateInput(v *DescribeCertificateInput, value smithyjson.Value) error { 3778 object := value.Object() 3779 defer object.Close() 3780 3781 if v.CertificateId != nil { 3782 ok := object.Key("CertificateId") 3783 ok.String(*v.CertificateId) 3784 } 3785 3786 if v.DirectoryId != nil { 3787 ok := object.Key("DirectoryId") 3788 ok.String(*v.DirectoryId) 3789 } 3790 3791 return nil 3792} 3793 3794func awsAwsjson11_serializeOpDocumentDescribeConditionalForwardersInput(v *DescribeConditionalForwardersInput, value smithyjson.Value) error { 3795 object := value.Object() 3796 defer object.Close() 3797 3798 if v.DirectoryId != nil { 3799 ok := object.Key("DirectoryId") 3800 ok.String(*v.DirectoryId) 3801 } 3802 3803 if v.RemoteDomainNames != nil { 3804 ok := object.Key("RemoteDomainNames") 3805 if err := awsAwsjson11_serializeDocumentRemoteDomainNames(v.RemoteDomainNames, ok); err != nil { 3806 return err 3807 } 3808 } 3809 3810 return nil 3811} 3812 3813func awsAwsjson11_serializeOpDocumentDescribeDirectoriesInput(v *DescribeDirectoriesInput, value smithyjson.Value) error { 3814 object := value.Object() 3815 defer object.Close() 3816 3817 if v.DirectoryIds != nil { 3818 ok := object.Key("DirectoryIds") 3819 if err := awsAwsjson11_serializeDocumentDirectoryIds(v.DirectoryIds, ok); err != nil { 3820 return err 3821 } 3822 } 3823 3824 if v.Limit != nil { 3825 ok := object.Key("Limit") 3826 ok.Integer(*v.Limit) 3827 } 3828 3829 if v.NextToken != nil { 3830 ok := object.Key("NextToken") 3831 ok.String(*v.NextToken) 3832 } 3833 3834 return nil 3835} 3836 3837func awsAwsjson11_serializeOpDocumentDescribeDomainControllersInput(v *DescribeDomainControllersInput, value smithyjson.Value) error { 3838 object := value.Object() 3839 defer object.Close() 3840 3841 if v.DirectoryId != nil { 3842 ok := object.Key("DirectoryId") 3843 ok.String(*v.DirectoryId) 3844 } 3845 3846 if v.DomainControllerIds != nil { 3847 ok := object.Key("DomainControllerIds") 3848 if err := awsAwsjson11_serializeDocumentDomainControllerIds(v.DomainControllerIds, ok); err != nil { 3849 return err 3850 } 3851 } 3852 3853 if v.Limit != nil { 3854 ok := object.Key("Limit") 3855 ok.Integer(*v.Limit) 3856 } 3857 3858 if v.NextToken != nil { 3859 ok := object.Key("NextToken") 3860 ok.String(*v.NextToken) 3861 } 3862 3863 return nil 3864} 3865 3866func awsAwsjson11_serializeOpDocumentDescribeEventTopicsInput(v *DescribeEventTopicsInput, value smithyjson.Value) error { 3867 object := value.Object() 3868 defer object.Close() 3869 3870 if v.DirectoryId != nil { 3871 ok := object.Key("DirectoryId") 3872 ok.String(*v.DirectoryId) 3873 } 3874 3875 if v.TopicNames != nil { 3876 ok := object.Key("TopicNames") 3877 if err := awsAwsjson11_serializeDocumentTopicNames(v.TopicNames, ok); err != nil { 3878 return err 3879 } 3880 } 3881 3882 return nil 3883} 3884 3885func awsAwsjson11_serializeOpDocumentDescribeLDAPSSettingsInput(v *DescribeLDAPSSettingsInput, value smithyjson.Value) error { 3886 object := value.Object() 3887 defer object.Close() 3888 3889 if v.DirectoryId != nil { 3890 ok := object.Key("DirectoryId") 3891 ok.String(*v.DirectoryId) 3892 } 3893 3894 if v.Limit != nil { 3895 ok := object.Key("Limit") 3896 ok.Integer(*v.Limit) 3897 } 3898 3899 if v.NextToken != nil { 3900 ok := object.Key("NextToken") 3901 ok.String(*v.NextToken) 3902 } 3903 3904 if len(v.Type) > 0 { 3905 ok := object.Key("Type") 3906 ok.String(string(v.Type)) 3907 } 3908 3909 return nil 3910} 3911 3912func awsAwsjson11_serializeOpDocumentDescribeRegionsInput(v *DescribeRegionsInput, value smithyjson.Value) error { 3913 object := value.Object() 3914 defer object.Close() 3915 3916 if v.DirectoryId != nil { 3917 ok := object.Key("DirectoryId") 3918 ok.String(*v.DirectoryId) 3919 } 3920 3921 if v.NextToken != nil { 3922 ok := object.Key("NextToken") 3923 ok.String(*v.NextToken) 3924 } 3925 3926 if v.RegionName != nil { 3927 ok := object.Key("RegionName") 3928 ok.String(*v.RegionName) 3929 } 3930 3931 return nil 3932} 3933 3934func awsAwsjson11_serializeOpDocumentDescribeSharedDirectoriesInput(v *DescribeSharedDirectoriesInput, value smithyjson.Value) error { 3935 object := value.Object() 3936 defer object.Close() 3937 3938 if v.Limit != nil { 3939 ok := object.Key("Limit") 3940 ok.Integer(*v.Limit) 3941 } 3942 3943 if v.NextToken != nil { 3944 ok := object.Key("NextToken") 3945 ok.String(*v.NextToken) 3946 } 3947 3948 if v.OwnerDirectoryId != nil { 3949 ok := object.Key("OwnerDirectoryId") 3950 ok.String(*v.OwnerDirectoryId) 3951 } 3952 3953 if v.SharedDirectoryIds != nil { 3954 ok := object.Key("SharedDirectoryIds") 3955 if err := awsAwsjson11_serializeDocumentDirectoryIds(v.SharedDirectoryIds, ok); err != nil { 3956 return err 3957 } 3958 } 3959 3960 return nil 3961} 3962 3963func awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(v *DescribeSnapshotsInput, value smithyjson.Value) error { 3964 object := value.Object() 3965 defer object.Close() 3966 3967 if v.DirectoryId != nil { 3968 ok := object.Key("DirectoryId") 3969 ok.String(*v.DirectoryId) 3970 } 3971 3972 if v.Limit != nil { 3973 ok := object.Key("Limit") 3974 ok.Integer(*v.Limit) 3975 } 3976 3977 if v.NextToken != nil { 3978 ok := object.Key("NextToken") 3979 ok.String(*v.NextToken) 3980 } 3981 3982 if v.SnapshotIds != nil { 3983 ok := object.Key("SnapshotIds") 3984 if err := awsAwsjson11_serializeDocumentSnapshotIds(v.SnapshotIds, ok); err != nil { 3985 return err 3986 } 3987 } 3988 3989 return nil 3990} 3991 3992func awsAwsjson11_serializeOpDocumentDescribeTrustsInput(v *DescribeTrustsInput, value smithyjson.Value) error { 3993 object := value.Object() 3994 defer object.Close() 3995 3996 if v.DirectoryId != nil { 3997 ok := object.Key("DirectoryId") 3998 ok.String(*v.DirectoryId) 3999 } 4000 4001 if v.Limit != nil { 4002 ok := object.Key("Limit") 4003 ok.Integer(*v.Limit) 4004 } 4005 4006 if v.NextToken != nil { 4007 ok := object.Key("NextToken") 4008 ok.String(*v.NextToken) 4009 } 4010 4011 if v.TrustIds != nil { 4012 ok := object.Key("TrustIds") 4013 if err := awsAwsjson11_serializeDocumentTrustIds(v.TrustIds, ok); err != nil { 4014 return err 4015 } 4016 } 4017 4018 return nil 4019} 4020 4021func awsAwsjson11_serializeOpDocumentDisableClientAuthenticationInput(v *DisableClientAuthenticationInput, value smithyjson.Value) error { 4022 object := value.Object() 4023 defer object.Close() 4024 4025 if v.DirectoryId != nil { 4026 ok := object.Key("DirectoryId") 4027 ok.String(*v.DirectoryId) 4028 } 4029 4030 if len(v.Type) > 0 { 4031 ok := object.Key("Type") 4032 ok.String(string(v.Type)) 4033 } 4034 4035 return nil 4036} 4037 4038func awsAwsjson11_serializeOpDocumentDisableLDAPSInput(v *DisableLDAPSInput, value smithyjson.Value) error { 4039 object := value.Object() 4040 defer object.Close() 4041 4042 if v.DirectoryId != nil { 4043 ok := object.Key("DirectoryId") 4044 ok.String(*v.DirectoryId) 4045 } 4046 4047 if len(v.Type) > 0 { 4048 ok := object.Key("Type") 4049 ok.String(string(v.Type)) 4050 } 4051 4052 return nil 4053} 4054 4055func awsAwsjson11_serializeOpDocumentDisableRadiusInput(v *DisableRadiusInput, value smithyjson.Value) error { 4056 object := value.Object() 4057 defer object.Close() 4058 4059 if v.DirectoryId != nil { 4060 ok := object.Key("DirectoryId") 4061 ok.String(*v.DirectoryId) 4062 } 4063 4064 return nil 4065} 4066 4067func awsAwsjson11_serializeOpDocumentDisableSsoInput(v *DisableSsoInput, value smithyjson.Value) error { 4068 object := value.Object() 4069 defer object.Close() 4070 4071 if v.DirectoryId != nil { 4072 ok := object.Key("DirectoryId") 4073 ok.String(*v.DirectoryId) 4074 } 4075 4076 if v.Password != nil { 4077 ok := object.Key("Password") 4078 ok.String(*v.Password) 4079 } 4080 4081 if v.UserName != nil { 4082 ok := object.Key("UserName") 4083 ok.String(*v.UserName) 4084 } 4085 4086 return nil 4087} 4088 4089func awsAwsjson11_serializeOpDocumentEnableClientAuthenticationInput(v *EnableClientAuthenticationInput, value smithyjson.Value) error { 4090 object := value.Object() 4091 defer object.Close() 4092 4093 if v.DirectoryId != nil { 4094 ok := object.Key("DirectoryId") 4095 ok.String(*v.DirectoryId) 4096 } 4097 4098 if len(v.Type) > 0 { 4099 ok := object.Key("Type") 4100 ok.String(string(v.Type)) 4101 } 4102 4103 return nil 4104} 4105 4106func awsAwsjson11_serializeOpDocumentEnableLDAPSInput(v *EnableLDAPSInput, value smithyjson.Value) error { 4107 object := value.Object() 4108 defer object.Close() 4109 4110 if v.DirectoryId != nil { 4111 ok := object.Key("DirectoryId") 4112 ok.String(*v.DirectoryId) 4113 } 4114 4115 if len(v.Type) > 0 { 4116 ok := object.Key("Type") 4117 ok.String(string(v.Type)) 4118 } 4119 4120 return nil 4121} 4122 4123func awsAwsjson11_serializeOpDocumentEnableRadiusInput(v *EnableRadiusInput, value smithyjson.Value) error { 4124 object := value.Object() 4125 defer object.Close() 4126 4127 if v.DirectoryId != nil { 4128 ok := object.Key("DirectoryId") 4129 ok.String(*v.DirectoryId) 4130 } 4131 4132 if v.RadiusSettings != nil { 4133 ok := object.Key("RadiusSettings") 4134 if err := awsAwsjson11_serializeDocumentRadiusSettings(v.RadiusSettings, ok); err != nil { 4135 return err 4136 } 4137 } 4138 4139 return nil 4140} 4141 4142func awsAwsjson11_serializeOpDocumentEnableSsoInput(v *EnableSsoInput, value smithyjson.Value) error { 4143 object := value.Object() 4144 defer object.Close() 4145 4146 if v.DirectoryId != nil { 4147 ok := object.Key("DirectoryId") 4148 ok.String(*v.DirectoryId) 4149 } 4150 4151 if v.Password != nil { 4152 ok := object.Key("Password") 4153 ok.String(*v.Password) 4154 } 4155 4156 if v.UserName != nil { 4157 ok := object.Key("UserName") 4158 ok.String(*v.UserName) 4159 } 4160 4161 return nil 4162} 4163 4164func awsAwsjson11_serializeOpDocumentGetDirectoryLimitsInput(v *GetDirectoryLimitsInput, value smithyjson.Value) error { 4165 object := value.Object() 4166 defer object.Close() 4167 4168 return nil 4169} 4170 4171func awsAwsjson11_serializeOpDocumentGetSnapshotLimitsInput(v *GetSnapshotLimitsInput, value smithyjson.Value) error { 4172 object := value.Object() 4173 defer object.Close() 4174 4175 if v.DirectoryId != nil { 4176 ok := object.Key("DirectoryId") 4177 ok.String(*v.DirectoryId) 4178 } 4179 4180 return nil 4181} 4182 4183func awsAwsjson11_serializeOpDocumentListCertificatesInput(v *ListCertificatesInput, value smithyjson.Value) error { 4184 object := value.Object() 4185 defer object.Close() 4186 4187 if v.DirectoryId != nil { 4188 ok := object.Key("DirectoryId") 4189 ok.String(*v.DirectoryId) 4190 } 4191 4192 if v.Limit != nil { 4193 ok := object.Key("Limit") 4194 ok.Integer(*v.Limit) 4195 } 4196 4197 if v.NextToken != nil { 4198 ok := object.Key("NextToken") 4199 ok.String(*v.NextToken) 4200 } 4201 4202 return nil 4203} 4204 4205func awsAwsjson11_serializeOpDocumentListIpRoutesInput(v *ListIpRoutesInput, value smithyjson.Value) error { 4206 object := value.Object() 4207 defer object.Close() 4208 4209 if v.DirectoryId != nil { 4210 ok := object.Key("DirectoryId") 4211 ok.String(*v.DirectoryId) 4212 } 4213 4214 if v.Limit != nil { 4215 ok := object.Key("Limit") 4216 ok.Integer(*v.Limit) 4217 } 4218 4219 if v.NextToken != nil { 4220 ok := object.Key("NextToken") 4221 ok.String(*v.NextToken) 4222 } 4223 4224 return nil 4225} 4226 4227func awsAwsjson11_serializeOpDocumentListLogSubscriptionsInput(v *ListLogSubscriptionsInput, value smithyjson.Value) error { 4228 object := value.Object() 4229 defer object.Close() 4230 4231 if v.DirectoryId != nil { 4232 ok := object.Key("DirectoryId") 4233 ok.String(*v.DirectoryId) 4234 } 4235 4236 if v.Limit != nil { 4237 ok := object.Key("Limit") 4238 ok.Integer(*v.Limit) 4239 } 4240 4241 if v.NextToken != nil { 4242 ok := object.Key("NextToken") 4243 ok.String(*v.NextToken) 4244 } 4245 4246 return nil 4247} 4248 4249func awsAwsjson11_serializeOpDocumentListSchemaExtensionsInput(v *ListSchemaExtensionsInput, value smithyjson.Value) error { 4250 object := value.Object() 4251 defer object.Close() 4252 4253 if v.DirectoryId != nil { 4254 ok := object.Key("DirectoryId") 4255 ok.String(*v.DirectoryId) 4256 } 4257 4258 if v.Limit != nil { 4259 ok := object.Key("Limit") 4260 ok.Integer(*v.Limit) 4261 } 4262 4263 if v.NextToken != nil { 4264 ok := object.Key("NextToken") 4265 ok.String(*v.NextToken) 4266 } 4267 4268 return nil 4269} 4270 4271func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error { 4272 object := value.Object() 4273 defer object.Close() 4274 4275 if v.Limit != nil { 4276 ok := object.Key("Limit") 4277 ok.Integer(*v.Limit) 4278 } 4279 4280 if v.NextToken != nil { 4281 ok := object.Key("NextToken") 4282 ok.String(*v.NextToken) 4283 } 4284 4285 if v.ResourceId != nil { 4286 ok := object.Key("ResourceId") 4287 ok.String(*v.ResourceId) 4288 } 4289 4290 return nil 4291} 4292 4293func awsAwsjson11_serializeOpDocumentRegisterCertificateInput(v *RegisterCertificateInput, value smithyjson.Value) error { 4294 object := value.Object() 4295 defer object.Close() 4296 4297 if v.CertificateData != nil { 4298 ok := object.Key("CertificateData") 4299 ok.String(*v.CertificateData) 4300 } 4301 4302 if v.ClientCertAuthSettings != nil { 4303 ok := object.Key("ClientCertAuthSettings") 4304 if err := awsAwsjson11_serializeDocumentClientCertAuthSettings(v.ClientCertAuthSettings, ok); err != nil { 4305 return err 4306 } 4307 } 4308 4309 if v.DirectoryId != nil { 4310 ok := object.Key("DirectoryId") 4311 ok.String(*v.DirectoryId) 4312 } 4313 4314 if len(v.Type) > 0 { 4315 ok := object.Key("Type") 4316 ok.String(string(v.Type)) 4317 } 4318 4319 return nil 4320} 4321 4322func awsAwsjson11_serializeOpDocumentRegisterEventTopicInput(v *RegisterEventTopicInput, value smithyjson.Value) error { 4323 object := value.Object() 4324 defer object.Close() 4325 4326 if v.DirectoryId != nil { 4327 ok := object.Key("DirectoryId") 4328 ok.String(*v.DirectoryId) 4329 } 4330 4331 if v.TopicName != nil { 4332 ok := object.Key("TopicName") 4333 ok.String(*v.TopicName) 4334 } 4335 4336 return nil 4337} 4338 4339func awsAwsjson11_serializeOpDocumentRejectSharedDirectoryInput(v *RejectSharedDirectoryInput, value smithyjson.Value) error { 4340 object := value.Object() 4341 defer object.Close() 4342 4343 if v.SharedDirectoryId != nil { 4344 ok := object.Key("SharedDirectoryId") 4345 ok.String(*v.SharedDirectoryId) 4346 } 4347 4348 return nil 4349} 4350 4351func awsAwsjson11_serializeOpDocumentRemoveIpRoutesInput(v *RemoveIpRoutesInput, value smithyjson.Value) error { 4352 object := value.Object() 4353 defer object.Close() 4354 4355 if v.CidrIps != nil { 4356 ok := object.Key("CidrIps") 4357 if err := awsAwsjson11_serializeDocumentCidrIps(v.CidrIps, ok); err != nil { 4358 return err 4359 } 4360 } 4361 4362 if v.DirectoryId != nil { 4363 ok := object.Key("DirectoryId") 4364 ok.String(*v.DirectoryId) 4365 } 4366 4367 return nil 4368} 4369 4370func awsAwsjson11_serializeOpDocumentRemoveRegionInput(v *RemoveRegionInput, value smithyjson.Value) error { 4371 object := value.Object() 4372 defer object.Close() 4373 4374 if v.DirectoryId != nil { 4375 ok := object.Key("DirectoryId") 4376 ok.String(*v.DirectoryId) 4377 } 4378 4379 return nil 4380} 4381 4382func awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput, value smithyjson.Value) error { 4383 object := value.Object() 4384 defer object.Close() 4385 4386 if v.ResourceId != nil { 4387 ok := object.Key("ResourceId") 4388 ok.String(*v.ResourceId) 4389 } 4390 4391 if v.TagKeys != nil { 4392 ok := object.Key("TagKeys") 4393 if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil { 4394 return err 4395 } 4396 } 4397 4398 return nil 4399} 4400 4401func awsAwsjson11_serializeOpDocumentResetUserPasswordInput(v *ResetUserPasswordInput, value smithyjson.Value) error { 4402 object := value.Object() 4403 defer object.Close() 4404 4405 if v.DirectoryId != nil { 4406 ok := object.Key("DirectoryId") 4407 ok.String(*v.DirectoryId) 4408 } 4409 4410 if v.NewPassword != nil { 4411 ok := object.Key("NewPassword") 4412 ok.String(*v.NewPassword) 4413 } 4414 4415 if v.UserName != nil { 4416 ok := object.Key("UserName") 4417 ok.String(*v.UserName) 4418 } 4419 4420 return nil 4421} 4422 4423func awsAwsjson11_serializeOpDocumentRestoreFromSnapshotInput(v *RestoreFromSnapshotInput, value smithyjson.Value) error { 4424 object := value.Object() 4425 defer object.Close() 4426 4427 if v.SnapshotId != nil { 4428 ok := object.Key("SnapshotId") 4429 ok.String(*v.SnapshotId) 4430 } 4431 4432 return nil 4433} 4434 4435func awsAwsjson11_serializeOpDocumentShareDirectoryInput(v *ShareDirectoryInput, value smithyjson.Value) error { 4436 object := value.Object() 4437 defer object.Close() 4438 4439 if v.DirectoryId != nil { 4440 ok := object.Key("DirectoryId") 4441 ok.String(*v.DirectoryId) 4442 } 4443 4444 if len(v.ShareMethod) > 0 { 4445 ok := object.Key("ShareMethod") 4446 ok.String(string(v.ShareMethod)) 4447 } 4448 4449 if v.ShareNotes != nil { 4450 ok := object.Key("ShareNotes") 4451 ok.String(*v.ShareNotes) 4452 } 4453 4454 if v.ShareTarget != nil { 4455 ok := object.Key("ShareTarget") 4456 if err := awsAwsjson11_serializeDocumentShareTarget(v.ShareTarget, ok); err != nil { 4457 return err 4458 } 4459 } 4460 4461 return nil 4462} 4463 4464func awsAwsjson11_serializeOpDocumentStartSchemaExtensionInput(v *StartSchemaExtensionInput, value smithyjson.Value) error { 4465 object := value.Object() 4466 defer object.Close() 4467 4468 if v.CreateSnapshotBeforeSchemaExtension { 4469 ok := object.Key("CreateSnapshotBeforeSchemaExtension") 4470 ok.Boolean(v.CreateSnapshotBeforeSchemaExtension) 4471 } 4472 4473 if v.Description != nil { 4474 ok := object.Key("Description") 4475 ok.String(*v.Description) 4476 } 4477 4478 if v.DirectoryId != nil { 4479 ok := object.Key("DirectoryId") 4480 ok.String(*v.DirectoryId) 4481 } 4482 4483 if v.LdifContent != nil { 4484 ok := object.Key("LdifContent") 4485 ok.String(*v.LdifContent) 4486 } 4487 4488 return nil 4489} 4490 4491func awsAwsjson11_serializeOpDocumentUnshareDirectoryInput(v *UnshareDirectoryInput, value smithyjson.Value) error { 4492 object := value.Object() 4493 defer object.Close() 4494 4495 if v.DirectoryId != nil { 4496 ok := object.Key("DirectoryId") 4497 ok.String(*v.DirectoryId) 4498 } 4499 4500 if v.UnshareTarget != nil { 4501 ok := object.Key("UnshareTarget") 4502 if err := awsAwsjson11_serializeDocumentUnshareTarget(v.UnshareTarget, ok); err != nil { 4503 return err 4504 } 4505 } 4506 4507 return nil 4508} 4509 4510func awsAwsjson11_serializeOpDocumentUpdateConditionalForwarderInput(v *UpdateConditionalForwarderInput, value smithyjson.Value) error { 4511 object := value.Object() 4512 defer object.Close() 4513 4514 if v.DirectoryId != nil { 4515 ok := object.Key("DirectoryId") 4516 ok.String(*v.DirectoryId) 4517 } 4518 4519 if v.DnsIpAddrs != nil { 4520 ok := object.Key("DnsIpAddrs") 4521 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.DnsIpAddrs, ok); err != nil { 4522 return err 4523 } 4524 } 4525 4526 if v.RemoteDomainName != nil { 4527 ok := object.Key("RemoteDomainName") 4528 ok.String(*v.RemoteDomainName) 4529 } 4530 4531 return nil 4532} 4533 4534func awsAwsjson11_serializeOpDocumentUpdateNumberOfDomainControllersInput(v *UpdateNumberOfDomainControllersInput, value smithyjson.Value) error { 4535 object := value.Object() 4536 defer object.Close() 4537 4538 if v.DesiredNumber != 0 { 4539 ok := object.Key("DesiredNumber") 4540 ok.Integer(v.DesiredNumber) 4541 } 4542 4543 if v.DirectoryId != nil { 4544 ok := object.Key("DirectoryId") 4545 ok.String(*v.DirectoryId) 4546 } 4547 4548 return nil 4549} 4550 4551func awsAwsjson11_serializeOpDocumentUpdateRadiusInput(v *UpdateRadiusInput, value smithyjson.Value) error { 4552 object := value.Object() 4553 defer object.Close() 4554 4555 if v.DirectoryId != nil { 4556 ok := object.Key("DirectoryId") 4557 ok.String(*v.DirectoryId) 4558 } 4559 4560 if v.RadiusSettings != nil { 4561 ok := object.Key("RadiusSettings") 4562 if err := awsAwsjson11_serializeDocumentRadiusSettings(v.RadiusSettings, ok); err != nil { 4563 return err 4564 } 4565 } 4566 4567 return nil 4568} 4569 4570func awsAwsjson11_serializeOpDocumentUpdateTrustInput(v *UpdateTrustInput, value smithyjson.Value) error { 4571 object := value.Object() 4572 defer object.Close() 4573 4574 if len(v.SelectiveAuth) > 0 { 4575 ok := object.Key("SelectiveAuth") 4576 ok.String(string(v.SelectiveAuth)) 4577 } 4578 4579 if v.TrustId != nil { 4580 ok := object.Key("TrustId") 4581 ok.String(*v.TrustId) 4582 } 4583 4584 return nil 4585} 4586 4587func awsAwsjson11_serializeOpDocumentVerifyTrustInput(v *VerifyTrustInput, value smithyjson.Value) error { 4588 object := value.Object() 4589 defer object.Close() 4590 4591 if v.TrustId != nil { 4592 ok := object.Key("TrustId") 4593 ok.String(*v.TrustId) 4594 } 4595 4596 return nil 4597} 4598