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_serializeOpDescribeClientAuthenticationSettings struct { 1052} 1053 1054func (*awsAwsjson11_serializeOpDescribeClientAuthenticationSettings) ID() string { 1055 return "OperationSerializer" 1056} 1057 1058func (m *awsAwsjson11_serializeOpDescribeClientAuthenticationSettings) 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.(*DescribeClientAuthenticationSettingsInput) 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.DescribeClientAuthenticationSettings") 1080 1081 jsonEncoder := smithyjson.NewEncoder() 1082 if err := awsAwsjson11_serializeOpDocumentDescribeClientAuthenticationSettingsInput(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_serializeOpDescribeConditionalForwarders struct { 1099} 1100 1101func (*awsAwsjson11_serializeOpDescribeConditionalForwarders) ID() string { 1102 return "OperationSerializer" 1103} 1104 1105func (m *awsAwsjson11_serializeOpDescribeConditionalForwarders) 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.(*DescribeConditionalForwardersInput) 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.DescribeConditionalForwarders") 1127 1128 jsonEncoder := smithyjson.NewEncoder() 1129 if err := awsAwsjson11_serializeOpDocumentDescribeConditionalForwardersInput(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_serializeOpDescribeDirectories struct { 1146} 1147 1148func (*awsAwsjson11_serializeOpDescribeDirectories) ID() string { 1149 return "OperationSerializer" 1150} 1151 1152func (m *awsAwsjson11_serializeOpDescribeDirectories) 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.(*DescribeDirectoriesInput) 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.DescribeDirectories") 1174 1175 jsonEncoder := smithyjson.NewEncoder() 1176 if err := awsAwsjson11_serializeOpDocumentDescribeDirectoriesInput(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_serializeOpDescribeDomainControllers struct { 1193} 1194 1195func (*awsAwsjson11_serializeOpDescribeDomainControllers) ID() string { 1196 return "OperationSerializer" 1197} 1198 1199func (m *awsAwsjson11_serializeOpDescribeDomainControllers) 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.(*DescribeDomainControllersInput) 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.DescribeDomainControllers") 1221 1222 jsonEncoder := smithyjson.NewEncoder() 1223 if err := awsAwsjson11_serializeOpDocumentDescribeDomainControllersInput(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_serializeOpDescribeEventTopics struct { 1240} 1241 1242func (*awsAwsjson11_serializeOpDescribeEventTopics) ID() string { 1243 return "OperationSerializer" 1244} 1245 1246func (m *awsAwsjson11_serializeOpDescribeEventTopics) 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.(*DescribeEventTopicsInput) 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.DescribeEventTopics") 1268 1269 jsonEncoder := smithyjson.NewEncoder() 1270 if err := awsAwsjson11_serializeOpDocumentDescribeEventTopicsInput(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_serializeOpDescribeLDAPSSettings struct { 1287} 1288 1289func (*awsAwsjson11_serializeOpDescribeLDAPSSettings) ID() string { 1290 return "OperationSerializer" 1291} 1292 1293func (m *awsAwsjson11_serializeOpDescribeLDAPSSettings) 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.(*DescribeLDAPSSettingsInput) 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.DescribeLDAPSSettings") 1315 1316 jsonEncoder := smithyjson.NewEncoder() 1317 if err := awsAwsjson11_serializeOpDocumentDescribeLDAPSSettingsInput(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_serializeOpDescribeRegions struct { 1334} 1335 1336func (*awsAwsjson11_serializeOpDescribeRegions) ID() string { 1337 return "OperationSerializer" 1338} 1339 1340func (m *awsAwsjson11_serializeOpDescribeRegions) 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.(*DescribeRegionsInput) 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.DescribeRegions") 1362 1363 jsonEncoder := smithyjson.NewEncoder() 1364 if err := awsAwsjson11_serializeOpDocumentDescribeRegionsInput(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_serializeOpDescribeSharedDirectories struct { 1381} 1382 1383func (*awsAwsjson11_serializeOpDescribeSharedDirectories) ID() string { 1384 return "OperationSerializer" 1385} 1386 1387func (m *awsAwsjson11_serializeOpDescribeSharedDirectories) 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.(*DescribeSharedDirectoriesInput) 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.DescribeSharedDirectories") 1409 1410 jsonEncoder := smithyjson.NewEncoder() 1411 if err := awsAwsjson11_serializeOpDocumentDescribeSharedDirectoriesInput(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_serializeOpDescribeSnapshots struct { 1428} 1429 1430func (*awsAwsjson11_serializeOpDescribeSnapshots) ID() string { 1431 return "OperationSerializer" 1432} 1433 1434func (m *awsAwsjson11_serializeOpDescribeSnapshots) 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.(*DescribeSnapshotsInput) 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.DescribeSnapshots") 1456 1457 jsonEncoder := smithyjson.NewEncoder() 1458 if err := awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(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_serializeOpDescribeTrusts struct { 1475} 1476 1477func (*awsAwsjson11_serializeOpDescribeTrusts) ID() string { 1478 return "OperationSerializer" 1479} 1480 1481func (m *awsAwsjson11_serializeOpDescribeTrusts) 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.(*DescribeTrustsInput) 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.DescribeTrusts") 1503 1504 jsonEncoder := smithyjson.NewEncoder() 1505 if err := awsAwsjson11_serializeOpDocumentDescribeTrustsInput(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_serializeOpDisableClientAuthentication struct { 1522} 1523 1524func (*awsAwsjson11_serializeOpDisableClientAuthentication) ID() string { 1525 return "OperationSerializer" 1526} 1527 1528func (m *awsAwsjson11_serializeOpDisableClientAuthentication) 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.(*DisableClientAuthenticationInput) 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.DisableClientAuthentication") 1550 1551 jsonEncoder := smithyjson.NewEncoder() 1552 if err := awsAwsjson11_serializeOpDocumentDisableClientAuthenticationInput(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_serializeOpDisableLDAPS struct { 1569} 1570 1571func (*awsAwsjson11_serializeOpDisableLDAPS) ID() string { 1572 return "OperationSerializer" 1573} 1574 1575func (m *awsAwsjson11_serializeOpDisableLDAPS) 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.(*DisableLDAPSInput) 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.DisableLDAPS") 1597 1598 jsonEncoder := smithyjson.NewEncoder() 1599 if err := awsAwsjson11_serializeOpDocumentDisableLDAPSInput(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_serializeOpDisableRadius struct { 1616} 1617 1618func (*awsAwsjson11_serializeOpDisableRadius) ID() string { 1619 return "OperationSerializer" 1620} 1621 1622func (m *awsAwsjson11_serializeOpDisableRadius) 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.(*DisableRadiusInput) 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.DisableRadius") 1644 1645 jsonEncoder := smithyjson.NewEncoder() 1646 if err := awsAwsjson11_serializeOpDocumentDisableRadiusInput(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_serializeOpDisableSso struct { 1663} 1664 1665func (*awsAwsjson11_serializeOpDisableSso) ID() string { 1666 return "OperationSerializer" 1667} 1668 1669func (m *awsAwsjson11_serializeOpDisableSso) 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.(*DisableSsoInput) 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.DisableSso") 1691 1692 jsonEncoder := smithyjson.NewEncoder() 1693 if err := awsAwsjson11_serializeOpDocumentDisableSsoInput(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_serializeOpEnableClientAuthentication struct { 1710} 1711 1712func (*awsAwsjson11_serializeOpEnableClientAuthentication) ID() string { 1713 return "OperationSerializer" 1714} 1715 1716func (m *awsAwsjson11_serializeOpEnableClientAuthentication) 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.(*EnableClientAuthenticationInput) 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.EnableClientAuthentication") 1738 1739 jsonEncoder := smithyjson.NewEncoder() 1740 if err := awsAwsjson11_serializeOpDocumentEnableClientAuthenticationInput(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_serializeOpEnableLDAPS struct { 1757} 1758 1759func (*awsAwsjson11_serializeOpEnableLDAPS) ID() string { 1760 return "OperationSerializer" 1761} 1762 1763func (m *awsAwsjson11_serializeOpEnableLDAPS) 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.(*EnableLDAPSInput) 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.EnableLDAPS") 1785 1786 jsonEncoder := smithyjson.NewEncoder() 1787 if err := awsAwsjson11_serializeOpDocumentEnableLDAPSInput(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_serializeOpEnableRadius struct { 1804} 1805 1806func (*awsAwsjson11_serializeOpEnableRadius) ID() string { 1807 return "OperationSerializer" 1808} 1809 1810func (m *awsAwsjson11_serializeOpEnableRadius) 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.(*EnableRadiusInput) 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.EnableRadius") 1832 1833 jsonEncoder := smithyjson.NewEncoder() 1834 if err := awsAwsjson11_serializeOpDocumentEnableRadiusInput(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_serializeOpEnableSso struct { 1851} 1852 1853func (*awsAwsjson11_serializeOpEnableSso) ID() string { 1854 return "OperationSerializer" 1855} 1856 1857func (m *awsAwsjson11_serializeOpEnableSso) 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.(*EnableSsoInput) 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.EnableSso") 1879 1880 jsonEncoder := smithyjson.NewEncoder() 1881 if err := awsAwsjson11_serializeOpDocumentEnableSsoInput(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_serializeOpGetDirectoryLimits struct { 1898} 1899 1900func (*awsAwsjson11_serializeOpGetDirectoryLimits) ID() string { 1901 return "OperationSerializer" 1902} 1903 1904func (m *awsAwsjson11_serializeOpGetDirectoryLimits) 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.(*GetDirectoryLimitsInput) 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.GetDirectoryLimits") 1926 1927 jsonEncoder := smithyjson.NewEncoder() 1928 if err := awsAwsjson11_serializeOpDocumentGetDirectoryLimitsInput(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_serializeOpGetSnapshotLimits struct { 1945} 1946 1947func (*awsAwsjson11_serializeOpGetSnapshotLimits) ID() string { 1948 return "OperationSerializer" 1949} 1950 1951func (m *awsAwsjson11_serializeOpGetSnapshotLimits) 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.(*GetSnapshotLimitsInput) 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.GetSnapshotLimits") 1973 1974 jsonEncoder := smithyjson.NewEncoder() 1975 if err := awsAwsjson11_serializeOpDocumentGetSnapshotLimitsInput(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_serializeOpListCertificates struct { 1992} 1993 1994func (*awsAwsjson11_serializeOpListCertificates) ID() string { 1995 return "OperationSerializer" 1996} 1997 1998func (m *awsAwsjson11_serializeOpListCertificates) 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.(*ListCertificatesInput) 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.ListCertificates") 2020 2021 jsonEncoder := smithyjson.NewEncoder() 2022 if err := awsAwsjson11_serializeOpDocumentListCertificatesInput(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_serializeOpListIpRoutes struct { 2039} 2040 2041func (*awsAwsjson11_serializeOpListIpRoutes) ID() string { 2042 return "OperationSerializer" 2043} 2044 2045func (m *awsAwsjson11_serializeOpListIpRoutes) 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.(*ListIpRoutesInput) 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.ListIpRoutes") 2067 2068 jsonEncoder := smithyjson.NewEncoder() 2069 if err := awsAwsjson11_serializeOpDocumentListIpRoutesInput(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_serializeOpListLogSubscriptions struct { 2086} 2087 2088func (*awsAwsjson11_serializeOpListLogSubscriptions) ID() string { 2089 return "OperationSerializer" 2090} 2091 2092func (m *awsAwsjson11_serializeOpListLogSubscriptions) 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.(*ListLogSubscriptionsInput) 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.ListLogSubscriptions") 2114 2115 jsonEncoder := smithyjson.NewEncoder() 2116 if err := awsAwsjson11_serializeOpDocumentListLogSubscriptionsInput(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_serializeOpListSchemaExtensions struct { 2133} 2134 2135func (*awsAwsjson11_serializeOpListSchemaExtensions) ID() string { 2136 return "OperationSerializer" 2137} 2138 2139func (m *awsAwsjson11_serializeOpListSchemaExtensions) 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.(*ListSchemaExtensionsInput) 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.ListSchemaExtensions") 2161 2162 jsonEncoder := smithyjson.NewEncoder() 2163 if err := awsAwsjson11_serializeOpDocumentListSchemaExtensionsInput(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_serializeOpListTagsForResource struct { 2180} 2181 2182func (*awsAwsjson11_serializeOpListTagsForResource) ID() string { 2183 return "OperationSerializer" 2184} 2185 2186func (m *awsAwsjson11_serializeOpListTagsForResource) 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.(*ListTagsForResourceInput) 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.ListTagsForResource") 2208 2209 jsonEncoder := smithyjson.NewEncoder() 2210 if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(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_serializeOpRegisterCertificate struct { 2227} 2228 2229func (*awsAwsjson11_serializeOpRegisterCertificate) ID() string { 2230 return "OperationSerializer" 2231} 2232 2233func (m *awsAwsjson11_serializeOpRegisterCertificate) 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.(*RegisterCertificateInput) 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.RegisterCertificate") 2255 2256 jsonEncoder := smithyjson.NewEncoder() 2257 if err := awsAwsjson11_serializeOpDocumentRegisterCertificateInput(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_serializeOpRegisterEventTopic struct { 2274} 2275 2276func (*awsAwsjson11_serializeOpRegisterEventTopic) ID() string { 2277 return "OperationSerializer" 2278} 2279 2280func (m *awsAwsjson11_serializeOpRegisterEventTopic) 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.(*RegisterEventTopicInput) 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.RegisterEventTopic") 2302 2303 jsonEncoder := smithyjson.NewEncoder() 2304 if err := awsAwsjson11_serializeOpDocumentRegisterEventTopicInput(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_serializeOpRejectSharedDirectory struct { 2321} 2322 2323func (*awsAwsjson11_serializeOpRejectSharedDirectory) ID() string { 2324 return "OperationSerializer" 2325} 2326 2327func (m *awsAwsjson11_serializeOpRejectSharedDirectory) 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.(*RejectSharedDirectoryInput) 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.RejectSharedDirectory") 2349 2350 jsonEncoder := smithyjson.NewEncoder() 2351 if err := awsAwsjson11_serializeOpDocumentRejectSharedDirectoryInput(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_serializeOpRemoveIpRoutes struct { 2368} 2369 2370func (*awsAwsjson11_serializeOpRemoveIpRoutes) ID() string { 2371 return "OperationSerializer" 2372} 2373 2374func (m *awsAwsjson11_serializeOpRemoveIpRoutes) 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.(*RemoveIpRoutesInput) 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.RemoveIpRoutes") 2396 2397 jsonEncoder := smithyjson.NewEncoder() 2398 if err := awsAwsjson11_serializeOpDocumentRemoveIpRoutesInput(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_serializeOpRemoveRegion struct { 2415} 2416 2417func (*awsAwsjson11_serializeOpRemoveRegion) ID() string { 2418 return "OperationSerializer" 2419} 2420 2421func (m *awsAwsjson11_serializeOpRemoveRegion) 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.(*RemoveRegionInput) 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.RemoveRegion") 2443 2444 jsonEncoder := smithyjson.NewEncoder() 2445 if err := awsAwsjson11_serializeOpDocumentRemoveRegionInput(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_serializeOpRemoveTagsFromResource struct { 2462} 2463 2464func (*awsAwsjson11_serializeOpRemoveTagsFromResource) ID() string { 2465 return "OperationSerializer" 2466} 2467 2468func (m *awsAwsjson11_serializeOpRemoveTagsFromResource) 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.(*RemoveTagsFromResourceInput) 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.RemoveTagsFromResource") 2490 2491 jsonEncoder := smithyjson.NewEncoder() 2492 if err := awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(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_serializeOpResetUserPassword struct { 2509} 2510 2511func (*awsAwsjson11_serializeOpResetUserPassword) ID() string { 2512 return "OperationSerializer" 2513} 2514 2515func (m *awsAwsjson11_serializeOpResetUserPassword) 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.(*ResetUserPasswordInput) 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.ResetUserPassword") 2537 2538 jsonEncoder := smithyjson.NewEncoder() 2539 if err := awsAwsjson11_serializeOpDocumentResetUserPasswordInput(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_serializeOpRestoreFromSnapshot struct { 2556} 2557 2558func (*awsAwsjson11_serializeOpRestoreFromSnapshot) ID() string { 2559 return "OperationSerializer" 2560} 2561 2562func (m *awsAwsjson11_serializeOpRestoreFromSnapshot) 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.(*RestoreFromSnapshotInput) 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.RestoreFromSnapshot") 2584 2585 jsonEncoder := smithyjson.NewEncoder() 2586 if err := awsAwsjson11_serializeOpDocumentRestoreFromSnapshotInput(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_serializeOpShareDirectory struct { 2603} 2604 2605func (*awsAwsjson11_serializeOpShareDirectory) ID() string { 2606 return "OperationSerializer" 2607} 2608 2609func (m *awsAwsjson11_serializeOpShareDirectory) 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.(*ShareDirectoryInput) 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.ShareDirectory") 2631 2632 jsonEncoder := smithyjson.NewEncoder() 2633 if err := awsAwsjson11_serializeOpDocumentShareDirectoryInput(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_serializeOpStartSchemaExtension struct { 2650} 2651 2652func (*awsAwsjson11_serializeOpStartSchemaExtension) ID() string { 2653 return "OperationSerializer" 2654} 2655 2656func (m *awsAwsjson11_serializeOpStartSchemaExtension) 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.(*StartSchemaExtensionInput) 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.StartSchemaExtension") 2678 2679 jsonEncoder := smithyjson.NewEncoder() 2680 if err := awsAwsjson11_serializeOpDocumentStartSchemaExtensionInput(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_serializeOpUnshareDirectory struct { 2697} 2698 2699func (*awsAwsjson11_serializeOpUnshareDirectory) ID() string { 2700 return "OperationSerializer" 2701} 2702 2703func (m *awsAwsjson11_serializeOpUnshareDirectory) 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.(*UnshareDirectoryInput) 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.UnshareDirectory") 2725 2726 jsonEncoder := smithyjson.NewEncoder() 2727 if err := awsAwsjson11_serializeOpDocumentUnshareDirectoryInput(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_serializeOpUpdateConditionalForwarder struct { 2744} 2745 2746func (*awsAwsjson11_serializeOpUpdateConditionalForwarder) ID() string { 2747 return "OperationSerializer" 2748} 2749 2750func (m *awsAwsjson11_serializeOpUpdateConditionalForwarder) 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.(*UpdateConditionalForwarderInput) 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.UpdateConditionalForwarder") 2772 2773 jsonEncoder := smithyjson.NewEncoder() 2774 if err := awsAwsjson11_serializeOpDocumentUpdateConditionalForwarderInput(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_serializeOpUpdateNumberOfDomainControllers struct { 2791} 2792 2793func (*awsAwsjson11_serializeOpUpdateNumberOfDomainControllers) ID() string { 2794 return "OperationSerializer" 2795} 2796 2797func (m *awsAwsjson11_serializeOpUpdateNumberOfDomainControllers) 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.(*UpdateNumberOfDomainControllersInput) 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.UpdateNumberOfDomainControllers") 2819 2820 jsonEncoder := smithyjson.NewEncoder() 2821 if err := awsAwsjson11_serializeOpDocumentUpdateNumberOfDomainControllersInput(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_serializeOpUpdateRadius struct { 2838} 2839 2840func (*awsAwsjson11_serializeOpUpdateRadius) ID() string { 2841 return "OperationSerializer" 2842} 2843 2844func (m *awsAwsjson11_serializeOpUpdateRadius) 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.(*UpdateRadiusInput) 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.UpdateRadius") 2866 2867 jsonEncoder := smithyjson.NewEncoder() 2868 if err := awsAwsjson11_serializeOpDocumentUpdateRadiusInput(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_serializeOpUpdateTrust struct { 2885} 2886 2887func (*awsAwsjson11_serializeOpUpdateTrust) ID() string { 2888 return "OperationSerializer" 2889} 2890 2891func (m *awsAwsjson11_serializeOpUpdateTrust) 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.(*UpdateTrustInput) 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.UpdateTrust") 2913 2914 jsonEncoder := smithyjson.NewEncoder() 2915 if err := awsAwsjson11_serializeOpDocumentUpdateTrustInput(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} 2930 2931type awsAwsjson11_serializeOpVerifyTrust struct { 2932} 2933 2934func (*awsAwsjson11_serializeOpVerifyTrust) ID() string { 2935 return "OperationSerializer" 2936} 2937 2938func (m *awsAwsjson11_serializeOpVerifyTrust) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2939 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2940) { 2941 request, ok := in.Request.(*smithyhttp.Request) 2942 if !ok { 2943 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2944 } 2945 2946 input, ok := in.Parameters.(*VerifyTrustInput) 2947 _ = input 2948 if !ok { 2949 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2950 } 2951 2952 request.Request.URL.Path = "/" 2953 request.Request.Method = "POST" 2954 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2955 if err != nil { 2956 return out, metadata, &smithy.SerializationError{Err: err} 2957 } 2958 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2959 httpBindingEncoder.SetHeader("X-Amz-Target").String("DirectoryService_20150416.VerifyTrust") 2960 2961 jsonEncoder := smithyjson.NewEncoder() 2962 if err := awsAwsjson11_serializeOpDocumentVerifyTrustInput(input, jsonEncoder.Value); err != nil { 2963 return out, metadata, &smithy.SerializationError{Err: err} 2964 } 2965 2966 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2967 return out, metadata, &smithy.SerializationError{Err: err} 2968 } 2969 2970 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2971 return out, metadata, &smithy.SerializationError{Err: err} 2972 } 2973 in.Request = request 2974 2975 return next.HandleSerialize(ctx, in) 2976} 2977func awsAwsjson11_serializeDocumentAttribute(v *types.Attribute, value smithyjson.Value) error { 2978 object := value.Object() 2979 defer object.Close() 2980 2981 if v.Name != nil { 2982 ok := object.Key("Name") 2983 ok.String(*v.Name) 2984 } 2985 2986 if v.Value != nil { 2987 ok := object.Key("Value") 2988 ok.String(*v.Value) 2989 } 2990 2991 return nil 2992} 2993 2994func awsAwsjson11_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error { 2995 array := value.Array() 2996 defer array.Close() 2997 2998 for i := range v { 2999 av := array.Value() 3000 if err := awsAwsjson11_serializeDocumentAttribute(&v[i], av); err != nil { 3001 return err 3002 } 3003 } 3004 return nil 3005} 3006 3007func awsAwsjson11_serializeDocumentCidrIps(v []string, value smithyjson.Value) error { 3008 array := value.Array() 3009 defer array.Close() 3010 3011 for i := range v { 3012 av := array.Value() 3013 av.String(v[i]) 3014 } 3015 return nil 3016} 3017 3018func awsAwsjson11_serializeDocumentClientCertAuthSettings(v *types.ClientCertAuthSettings, value smithyjson.Value) error { 3019 object := value.Object() 3020 defer object.Close() 3021 3022 if v.OCSPUrl != nil { 3023 ok := object.Key("OCSPUrl") 3024 ok.String(*v.OCSPUrl) 3025 } 3026 3027 return nil 3028} 3029 3030func awsAwsjson11_serializeDocumentDirectoryConnectSettings(v *types.DirectoryConnectSettings, value smithyjson.Value) error { 3031 object := value.Object() 3032 defer object.Close() 3033 3034 if v.CustomerDnsIps != nil { 3035 ok := object.Key("CustomerDnsIps") 3036 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.CustomerDnsIps, ok); err != nil { 3037 return err 3038 } 3039 } 3040 3041 if v.CustomerUserName != nil { 3042 ok := object.Key("CustomerUserName") 3043 ok.String(*v.CustomerUserName) 3044 } 3045 3046 if v.SubnetIds != nil { 3047 ok := object.Key("SubnetIds") 3048 if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil { 3049 return err 3050 } 3051 } 3052 3053 if v.VpcId != nil { 3054 ok := object.Key("VpcId") 3055 ok.String(*v.VpcId) 3056 } 3057 3058 return nil 3059} 3060 3061func awsAwsjson11_serializeDocumentDirectoryIds(v []string, value smithyjson.Value) error { 3062 array := value.Array() 3063 defer array.Close() 3064 3065 for i := range v { 3066 av := array.Value() 3067 av.String(v[i]) 3068 } 3069 return nil 3070} 3071 3072func awsAwsjson11_serializeDocumentDirectoryVpcSettings(v *types.DirectoryVpcSettings, value smithyjson.Value) error { 3073 object := value.Object() 3074 defer object.Close() 3075 3076 if v.SubnetIds != nil { 3077 ok := object.Key("SubnetIds") 3078 if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil { 3079 return err 3080 } 3081 } 3082 3083 if v.VpcId != nil { 3084 ok := object.Key("VpcId") 3085 ok.String(*v.VpcId) 3086 } 3087 3088 return nil 3089} 3090 3091func awsAwsjson11_serializeDocumentDnsIpAddrs(v []string, value smithyjson.Value) error { 3092 array := value.Array() 3093 defer array.Close() 3094 3095 for i := range v { 3096 av := array.Value() 3097 av.String(v[i]) 3098 } 3099 return nil 3100} 3101 3102func awsAwsjson11_serializeDocumentDomainControllerIds(v []string, value smithyjson.Value) error { 3103 array := value.Array() 3104 defer array.Close() 3105 3106 for i := range v { 3107 av := array.Value() 3108 av.String(v[i]) 3109 } 3110 return nil 3111} 3112 3113func awsAwsjson11_serializeDocumentIpRoute(v *types.IpRoute, value smithyjson.Value) error { 3114 object := value.Object() 3115 defer object.Close() 3116 3117 if v.CidrIp != nil { 3118 ok := object.Key("CidrIp") 3119 ok.String(*v.CidrIp) 3120 } 3121 3122 if v.Description != nil { 3123 ok := object.Key("Description") 3124 ok.String(*v.Description) 3125 } 3126 3127 return nil 3128} 3129 3130func awsAwsjson11_serializeDocumentIpRoutes(v []types.IpRoute, value smithyjson.Value) error { 3131 array := value.Array() 3132 defer array.Close() 3133 3134 for i := range v { 3135 av := array.Value() 3136 if err := awsAwsjson11_serializeDocumentIpRoute(&v[i], av); err != nil { 3137 return err 3138 } 3139 } 3140 return nil 3141} 3142 3143func awsAwsjson11_serializeDocumentRadiusSettings(v *types.RadiusSettings, value smithyjson.Value) error { 3144 object := value.Object() 3145 defer object.Close() 3146 3147 if len(v.AuthenticationProtocol) > 0 { 3148 ok := object.Key("AuthenticationProtocol") 3149 ok.String(string(v.AuthenticationProtocol)) 3150 } 3151 3152 if v.DisplayLabel != nil { 3153 ok := object.Key("DisplayLabel") 3154 ok.String(*v.DisplayLabel) 3155 } 3156 3157 if v.RadiusPort != 0 { 3158 ok := object.Key("RadiusPort") 3159 ok.Integer(v.RadiusPort) 3160 } 3161 3162 if v.RadiusRetries != 0 { 3163 ok := object.Key("RadiusRetries") 3164 ok.Integer(v.RadiusRetries) 3165 } 3166 3167 if v.RadiusServers != nil { 3168 ok := object.Key("RadiusServers") 3169 if err := awsAwsjson11_serializeDocumentServers(v.RadiusServers, ok); err != nil { 3170 return err 3171 } 3172 } 3173 3174 if v.RadiusTimeout != 0 { 3175 ok := object.Key("RadiusTimeout") 3176 ok.Integer(v.RadiusTimeout) 3177 } 3178 3179 if v.SharedSecret != nil { 3180 ok := object.Key("SharedSecret") 3181 ok.String(*v.SharedSecret) 3182 } 3183 3184 if v.UseSameUsername { 3185 ok := object.Key("UseSameUsername") 3186 ok.Boolean(v.UseSameUsername) 3187 } 3188 3189 return nil 3190} 3191 3192func awsAwsjson11_serializeDocumentRemoteDomainNames(v []string, value smithyjson.Value) error { 3193 array := value.Array() 3194 defer array.Close() 3195 3196 for i := range v { 3197 av := array.Value() 3198 av.String(v[i]) 3199 } 3200 return nil 3201} 3202 3203func awsAwsjson11_serializeDocumentServers(v []string, value smithyjson.Value) error { 3204 array := value.Array() 3205 defer array.Close() 3206 3207 for i := range v { 3208 av := array.Value() 3209 av.String(v[i]) 3210 } 3211 return nil 3212} 3213 3214func awsAwsjson11_serializeDocumentShareTarget(v *types.ShareTarget, value smithyjson.Value) error { 3215 object := value.Object() 3216 defer object.Close() 3217 3218 if v.Id != nil { 3219 ok := object.Key("Id") 3220 ok.String(*v.Id) 3221 } 3222 3223 if len(v.Type) > 0 { 3224 ok := object.Key("Type") 3225 ok.String(string(v.Type)) 3226 } 3227 3228 return nil 3229} 3230 3231func awsAwsjson11_serializeDocumentSnapshotIds(v []string, value smithyjson.Value) error { 3232 array := value.Array() 3233 defer array.Close() 3234 3235 for i := range v { 3236 av := array.Value() 3237 av.String(v[i]) 3238 } 3239 return nil 3240} 3241 3242func awsAwsjson11_serializeDocumentSubnetIds(v []string, value smithyjson.Value) error { 3243 array := value.Array() 3244 defer array.Close() 3245 3246 for i := range v { 3247 av := array.Value() 3248 av.String(v[i]) 3249 } 3250 return nil 3251} 3252 3253func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 3254 object := value.Object() 3255 defer object.Close() 3256 3257 if v.Key != nil { 3258 ok := object.Key("Key") 3259 ok.String(*v.Key) 3260 } 3261 3262 if v.Value != nil { 3263 ok := object.Key("Value") 3264 ok.String(*v.Value) 3265 } 3266 3267 return nil 3268} 3269 3270func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error { 3271 array := value.Array() 3272 defer array.Close() 3273 3274 for i := range v { 3275 av := array.Value() 3276 av.String(v[i]) 3277 } 3278 return nil 3279} 3280 3281func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error { 3282 array := value.Array() 3283 defer array.Close() 3284 3285 for i := range v { 3286 av := array.Value() 3287 if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil { 3288 return err 3289 } 3290 } 3291 return nil 3292} 3293 3294func awsAwsjson11_serializeDocumentTopicNames(v []string, value smithyjson.Value) error { 3295 array := value.Array() 3296 defer array.Close() 3297 3298 for i := range v { 3299 av := array.Value() 3300 av.String(v[i]) 3301 } 3302 return nil 3303} 3304 3305func awsAwsjson11_serializeDocumentTrustIds(v []string, value smithyjson.Value) error { 3306 array := value.Array() 3307 defer array.Close() 3308 3309 for i := range v { 3310 av := array.Value() 3311 av.String(v[i]) 3312 } 3313 return nil 3314} 3315 3316func awsAwsjson11_serializeDocumentUnshareTarget(v *types.UnshareTarget, value smithyjson.Value) error { 3317 object := value.Object() 3318 defer object.Close() 3319 3320 if v.Id != nil { 3321 ok := object.Key("Id") 3322 ok.String(*v.Id) 3323 } 3324 3325 if len(v.Type) > 0 { 3326 ok := object.Key("Type") 3327 ok.String(string(v.Type)) 3328 } 3329 3330 return nil 3331} 3332 3333func awsAwsjson11_serializeOpDocumentAcceptSharedDirectoryInput(v *AcceptSharedDirectoryInput, value smithyjson.Value) error { 3334 object := value.Object() 3335 defer object.Close() 3336 3337 if v.SharedDirectoryId != nil { 3338 ok := object.Key("SharedDirectoryId") 3339 ok.String(*v.SharedDirectoryId) 3340 } 3341 3342 return nil 3343} 3344 3345func awsAwsjson11_serializeOpDocumentAddIpRoutesInput(v *AddIpRoutesInput, value smithyjson.Value) error { 3346 object := value.Object() 3347 defer object.Close() 3348 3349 if v.DirectoryId != nil { 3350 ok := object.Key("DirectoryId") 3351 ok.String(*v.DirectoryId) 3352 } 3353 3354 if v.IpRoutes != nil { 3355 ok := object.Key("IpRoutes") 3356 if err := awsAwsjson11_serializeDocumentIpRoutes(v.IpRoutes, ok); err != nil { 3357 return err 3358 } 3359 } 3360 3361 if v.UpdateSecurityGroupForDirectoryControllers { 3362 ok := object.Key("UpdateSecurityGroupForDirectoryControllers") 3363 ok.Boolean(v.UpdateSecurityGroupForDirectoryControllers) 3364 } 3365 3366 return nil 3367} 3368 3369func awsAwsjson11_serializeOpDocumentAddRegionInput(v *AddRegionInput, value smithyjson.Value) error { 3370 object := value.Object() 3371 defer object.Close() 3372 3373 if v.DirectoryId != nil { 3374 ok := object.Key("DirectoryId") 3375 ok.String(*v.DirectoryId) 3376 } 3377 3378 if v.RegionName != nil { 3379 ok := object.Key("RegionName") 3380 ok.String(*v.RegionName) 3381 } 3382 3383 if v.VPCSettings != nil { 3384 ok := object.Key("VPCSettings") 3385 if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VPCSettings, ok); err != nil { 3386 return err 3387 } 3388 } 3389 3390 return nil 3391} 3392 3393func awsAwsjson11_serializeOpDocumentAddTagsToResourceInput(v *AddTagsToResourceInput, value smithyjson.Value) error { 3394 object := value.Object() 3395 defer object.Close() 3396 3397 if v.ResourceId != nil { 3398 ok := object.Key("ResourceId") 3399 ok.String(*v.ResourceId) 3400 } 3401 3402 if v.Tags != nil { 3403 ok := object.Key("Tags") 3404 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3405 return err 3406 } 3407 } 3408 3409 return nil 3410} 3411 3412func awsAwsjson11_serializeOpDocumentCancelSchemaExtensionInput(v *CancelSchemaExtensionInput, value smithyjson.Value) error { 3413 object := value.Object() 3414 defer object.Close() 3415 3416 if v.DirectoryId != nil { 3417 ok := object.Key("DirectoryId") 3418 ok.String(*v.DirectoryId) 3419 } 3420 3421 if v.SchemaExtensionId != nil { 3422 ok := object.Key("SchemaExtensionId") 3423 ok.String(*v.SchemaExtensionId) 3424 } 3425 3426 return nil 3427} 3428 3429func awsAwsjson11_serializeOpDocumentConnectDirectoryInput(v *ConnectDirectoryInput, value smithyjson.Value) error { 3430 object := value.Object() 3431 defer object.Close() 3432 3433 if v.ConnectSettings != nil { 3434 ok := object.Key("ConnectSettings") 3435 if err := awsAwsjson11_serializeDocumentDirectoryConnectSettings(v.ConnectSettings, ok); err != nil { 3436 return err 3437 } 3438 } 3439 3440 if v.Description != nil { 3441 ok := object.Key("Description") 3442 ok.String(*v.Description) 3443 } 3444 3445 if v.Name != nil { 3446 ok := object.Key("Name") 3447 ok.String(*v.Name) 3448 } 3449 3450 if v.Password != nil { 3451 ok := object.Key("Password") 3452 ok.String(*v.Password) 3453 } 3454 3455 if v.ShortName != nil { 3456 ok := object.Key("ShortName") 3457 ok.String(*v.ShortName) 3458 } 3459 3460 if len(v.Size) > 0 { 3461 ok := object.Key("Size") 3462 ok.String(string(v.Size)) 3463 } 3464 3465 if v.Tags != nil { 3466 ok := object.Key("Tags") 3467 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3468 return err 3469 } 3470 } 3471 3472 return nil 3473} 3474 3475func awsAwsjson11_serializeOpDocumentCreateAliasInput(v *CreateAliasInput, value smithyjson.Value) error { 3476 object := value.Object() 3477 defer object.Close() 3478 3479 if v.Alias != nil { 3480 ok := object.Key("Alias") 3481 ok.String(*v.Alias) 3482 } 3483 3484 if v.DirectoryId != nil { 3485 ok := object.Key("DirectoryId") 3486 ok.String(*v.DirectoryId) 3487 } 3488 3489 return nil 3490} 3491 3492func awsAwsjson11_serializeOpDocumentCreateComputerInput(v *CreateComputerInput, value smithyjson.Value) error { 3493 object := value.Object() 3494 defer object.Close() 3495 3496 if v.ComputerAttributes != nil { 3497 ok := object.Key("ComputerAttributes") 3498 if err := awsAwsjson11_serializeDocumentAttributes(v.ComputerAttributes, ok); err != nil { 3499 return err 3500 } 3501 } 3502 3503 if v.ComputerName != nil { 3504 ok := object.Key("ComputerName") 3505 ok.String(*v.ComputerName) 3506 } 3507 3508 if v.DirectoryId != nil { 3509 ok := object.Key("DirectoryId") 3510 ok.String(*v.DirectoryId) 3511 } 3512 3513 if v.OrganizationalUnitDistinguishedName != nil { 3514 ok := object.Key("OrganizationalUnitDistinguishedName") 3515 ok.String(*v.OrganizationalUnitDistinguishedName) 3516 } 3517 3518 if v.Password != nil { 3519 ok := object.Key("Password") 3520 ok.String(*v.Password) 3521 } 3522 3523 return nil 3524} 3525 3526func awsAwsjson11_serializeOpDocumentCreateConditionalForwarderInput(v *CreateConditionalForwarderInput, value smithyjson.Value) error { 3527 object := value.Object() 3528 defer object.Close() 3529 3530 if v.DirectoryId != nil { 3531 ok := object.Key("DirectoryId") 3532 ok.String(*v.DirectoryId) 3533 } 3534 3535 if v.DnsIpAddrs != nil { 3536 ok := object.Key("DnsIpAddrs") 3537 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.DnsIpAddrs, ok); err != nil { 3538 return err 3539 } 3540 } 3541 3542 if v.RemoteDomainName != nil { 3543 ok := object.Key("RemoteDomainName") 3544 ok.String(*v.RemoteDomainName) 3545 } 3546 3547 return nil 3548} 3549 3550func awsAwsjson11_serializeOpDocumentCreateDirectoryInput(v *CreateDirectoryInput, value smithyjson.Value) error { 3551 object := value.Object() 3552 defer object.Close() 3553 3554 if v.Description != nil { 3555 ok := object.Key("Description") 3556 ok.String(*v.Description) 3557 } 3558 3559 if v.Name != nil { 3560 ok := object.Key("Name") 3561 ok.String(*v.Name) 3562 } 3563 3564 if v.Password != nil { 3565 ok := object.Key("Password") 3566 ok.String(*v.Password) 3567 } 3568 3569 if v.ShortName != nil { 3570 ok := object.Key("ShortName") 3571 ok.String(*v.ShortName) 3572 } 3573 3574 if len(v.Size) > 0 { 3575 ok := object.Key("Size") 3576 ok.String(string(v.Size)) 3577 } 3578 3579 if v.Tags != nil { 3580 ok := object.Key("Tags") 3581 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3582 return err 3583 } 3584 } 3585 3586 if v.VpcSettings != nil { 3587 ok := object.Key("VpcSettings") 3588 if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VpcSettings, ok); err != nil { 3589 return err 3590 } 3591 } 3592 3593 return nil 3594} 3595 3596func awsAwsjson11_serializeOpDocumentCreateLogSubscriptionInput(v *CreateLogSubscriptionInput, value smithyjson.Value) error { 3597 object := value.Object() 3598 defer object.Close() 3599 3600 if v.DirectoryId != nil { 3601 ok := object.Key("DirectoryId") 3602 ok.String(*v.DirectoryId) 3603 } 3604 3605 if v.LogGroupName != nil { 3606 ok := object.Key("LogGroupName") 3607 ok.String(*v.LogGroupName) 3608 } 3609 3610 return nil 3611} 3612 3613func awsAwsjson11_serializeOpDocumentCreateMicrosoftADInput(v *CreateMicrosoftADInput, value smithyjson.Value) error { 3614 object := value.Object() 3615 defer object.Close() 3616 3617 if v.Description != nil { 3618 ok := object.Key("Description") 3619 ok.String(*v.Description) 3620 } 3621 3622 if len(v.Edition) > 0 { 3623 ok := object.Key("Edition") 3624 ok.String(string(v.Edition)) 3625 } 3626 3627 if v.Name != nil { 3628 ok := object.Key("Name") 3629 ok.String(*v.Name) 3630 } 3631 3632 if v.Password != nil { 3633 ok := object.Key("Password") 3634 ok.String(*v.Password) 3635 } 3636 3637 if v.ShortName != nil { 3638 ok := object.Key("ShortName") 3639 ok.String(*v.ShortName) 3640 } 3641 3642 if v.Tags != nil { 3643 ok := object.Key("Tags") 3644 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 3645 return err 3646 } 3647 } 3648 3649 if v.VpcSettings != nil { 3650 ok := object.Key("VpcSettings") 3651 if err := awsAwsjson11_serializeDocumentDirectoryVpcSettings(v.VpcSettings, ok); err != nil { 3652 return err 3653 } 3654 } 3655 3656 return nil 3657} 3658 3659func awsAwsjson11_serializeOpDocumentCreateSnapshotInput(v *CreateSnapshotInput, value smithyjson.Value) error { 3660 object := value.Object() 3661 defer object.Close() 3662 3663 if v.DirectoryId != nil { 3664 ok := object.Key("DirectoryId") 3665 ok.String(*v.DirectoryId) 3666 } 3667 3668 if v.Name != nil { 3669 ok := object.Key("Name") 3670 ok.String(*v.Name) 3671 } 3672 3673 return nil 3674} 3675 3676func awsAwsjson11_serializeOpDocumentCreateTrustInput(v *CreateTrustInput, value smithyjson.Value) error { 3677 object := value.Object() 3678 defer object.Close() 3679 3680 if v.ConditionalForwarderIpAddrs != nil { 3681 ok := object.Key("ConditionalForwarderIpAddrs") 3682 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.ConditionalForwarderIpAddrs, ok); err != nil { 3683 return err 3684 } 3685 } 3686 3687 if v.DirectoryId != nil { 3688 ok := object.Key("DirectoryId") 3689 ok.String(*v.DirectoryId) 3690 } 3691 3692 if v.RemoteDomainName != nil { 3693 ok := object.Key("RemoteDomainName") 3694 ok.String(*v.RemoteDomainName) 3695 } 3696 3697 if len(v.SelectiveAuth) > 0 { 3698 ok := object.Key("SelectiveAuth") 3699 ok.String(string(v.SelectiveAuth)) 3700 } 3701 3702 if len(v.TrustDirection) > 0 { 3703 ok := object.Key("TrustDirection") 3704 ok.String(string(v.TrustDirection)) 3705 } 3706 3707 if v.TrustPassword != nil { 3708 ok := object.Key("TrustPassword") 3709 ok.String(*v.TrustPassword) 3710 } 3711 3712 if len(v.TrustType) > 0 { 3713 ok := object.Key("TrustType") 3714 ok.String(string(v.TrustType)) 3715 } 3716 3717 return nil 3718} 3719 3720func awsAwsjson11_serializeOpDocumentDeleteConditionalForwarderInput(v *DeleteConditionalForwarderInput, value smithyjson.Value) error { 3721 object := value.Object() 3722 defer object.Close() 3723 3724 if v.DirectoryId != nil { 3725 ok := object.Key("DirectoryId") 3726 ok.String(*v.DirectoryId) 3727 } 3728 3729 if v.RemoteDomainName != nil { 3730 ok := object.Key("RemoteDomainName") 3731 ok.String(*v.RemoteDomainName) 3732 } 3733 3734 return nil 3735} 3736 3737func awsAwsjson11_serializeOpDocumentDeleteDirectoryInput(v *DeleteDirectoryInput, value smithyjson.Value) error { 3738 object := value.Object() 3739 defer object.Close() 3740 3741 if v.DirectoryId != nil { 3742 ok := object.Key("DirectoryId") 3743 ok.String(*v.DirectoryId) 3744 } 3745 3746 return nil 3747} 3748 3749func awsAwsjson11_serializeOpDocumentDeleteLogSubscriptionInput(v *DeleteLogSubscriptionInput, value smithyjson.Value) error { 3750 object := value.Object() 3751 defer object.Close() 3752 3753 if v.DirectoryId != nil { 3754 ok := object.Key("DirectoryId") 3755 ok.String(*v.DirectoryId) 3756 } 3757 3758 return nil 3759} 3760 3761func awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(v *DeleteSnapshotInput, value smithyjson.Value) error { 3762 object := value.Object() 3763 defer object.Close() 3764 3765 if v.SnapshotId != nil { 3766 ok := object.Key("SnapshotId") 3767 ok.String(*v.SnapshotId) 3768 } 3769 3770 return nil 3771} 3772 3773func awsAwsjson11_serializeOpDocumentDeleteTrustInput(v *DeleteTrustInput, value smithyjson.Value) error { 3774 object := value.Object() 3775 defer object.Close() 3776 3777 if v.DeleteAssociatedConditionalForwarder { 3778 ok := object.Key("DeleteAssociatedConditionalForwarder") 3779 ok.Boolean(v.DeleteAssociatedConditionalForwarder) 3780 } 3781 3782 if v.TrustId != nil { 3783 ok := object.Key("TrustId") 3784 ok.String(*v.TrustId) 3785 } 3786 3787 return nil 3788} 3789 3790func awsAwsjson11_serializeOpDocumentDeregisterCertificateInput(v *DeregisterCertificateInput, value smithyjson.Value) error { 3791 object := value.Object() 3792 defer object.Close() 3793 3794 if v.CertificateId != nil { 3795 ok := object.Key("CertificateId") 3796 ok.String(*v.CertificateId) 3797 } 3798 3799 if v.DirectoryId != nil { 3800 ok := object.Key("DirectoryId") 3801 ok.String(*v.DirectoryId) 3802 } 3803 3804 return nil 3805} 3806 3807func awsAwsjson11_serializeOpDocumentDeregisterEventTopicInput(v *DeregisterEventTopicInput, value smithyjson.Value) error { 3808 object := value.Object() 3809 defer object.Close() 3810 3811 if v.DirectoryId != nil { 3812 ok := object.Key("DirectoryId") 3813 ok.String(*v.DirectoryId) 3814 } 3815 3816 if v.TopicName != nil { 3817 ok := object.Key("TopicName") 3818 ok.String(*v.TopicName) 3819 } 3820 3821 return nil 3822} 3823 3824func awsAwsjson11_serializeOpDocumentDescribeCertificateInput(v *DescribeCertificateInput, value smithyjson.Value) error { 3825 object := value.Object() 3826 defer object.Close() 3827 3828 if v.CertificateId != nil { 3829 ok := object.Key("CertificateId") 3830 ok.String(*v.CertificateId) 3831 } 3832 3833 if v.DirectoryId != nil { 3834 ok := object.Key("DirectoryId") 3835 ok.String(*v.DirectoryId) 3836 } 3837 3838 return nil 3839} 3840 3841func awsAwsjson11_serializeOpDocumentDescribeClientAuthenticationSettingsInput(v *DescribeClientAuthenticationSettingsInput, value smithyjson.Value) error { 3842 object := value.Object() 3843 defer object.Close() 3844 3845 if v.DirectoryId != nil { 3846 ok := object.Key("DirectoryId") 3847 ok.String(*v.DirectoryId) 3848 } 3849 3850 if v.Limit != nil { 3851 ok := object.Key("Limit") 3852 ok.Integer(*v.Limit) 3853 } 3854 3855 if v.NextToken != nil { 3856 ok := object.Key("NextToken") 3857 ok.String(*v.NextToken) 3858 } 3859 3860 if len(v.Type) > 0 { 3861 ok := object.Key("Type") 3862 ok.String(string(v.Type)) 3863 } 3864 3865 return nil 3866} 3867 3868func awsAwsjson11_serializeOpDocumentDescribeConditionalForwardersInput(v *DescribeConditionalForwardersInput, value smithyjson.Value) error { 3869 object := value.Object() 3870 defer object.Close() 3871 3872 if v.DirectoryId != nil { 3873 ok := object.Key("DirectoryId") 3874 ok.String(*v.DirectoryId) 3875 } 3876 3877 if v.RemoteDomainNames != nil { 3878 ok := object.Key("RemoteDomainNames") 3879 if err := awsAwsjson11_serializeDocumentRemoteDomainNames(v.RemoteDomainNames, ok); err != nil { 3880 return err 3881 } 3882 } 3883 3884 return nil 3885} 3886 3887func awsAwsjson11_serializeOpDocumentDescribeDirectoriesInput(v *DescribeDirectoriesInput, value smithyjson.Value) error { 3888 object := value.Object() 3889 defer object.Close() 3890 3891 if v.DirectoryIds != nil { 3892 ok := object.Key("DirectoryIds") 3893 if err := awsAwsjson11_serializeDocumentDirectoryIds(v.DirectoryIds, ok); err != nil { 3894 return err 3895 } 3896 } 3897 3898 if v.Limit != nil { 3899 ok := object.Key("Limit") 3900 ok.Integer(*v.Limit) 3901 } 3902 3903 if v.NextToken != nil { 3904 ok := object.Key("NextToken") 3905 ok.String(*v.NextToken) 3906 } 3907 3908 return nil 3909} 3910 3911func awsAwsjson11_serializeOpDocumentDescribeDomainControllersInput(v *DescribeDomainControllersInput, value smithyjson.Value) error { 3912 object := value.Object() 3913 defer object.Close() 3914 3915 if v.DirectoryId != nil { 3916 ok := object.Key("DirectoryId") 3917 ok.String(*v.DirectoryId) 3918 } 3919 3920 if v.DomainControllerIds != nil { 3921 ok := object.Key("DomainControllerIds") 3922 if err := awsAwsjson11_serializeDocumentDomainControllerIds(v.DomainControllerIds, ok); err != nil { 3923 return err 3924 } 3925 } 3926 3927 if v.Limit != nil { 3928 ok := object.Key("Limit") 3929 ok.Integer(*v.Limit) 3930 } 3931 3932 if v.NextToken != nil { 3933 ok := object.Key("NextToken") 3934 ok.String(*v.NextToken) 3935 } 3936 3937 return nil 3938} 3939 3940func awsAwsjson11_serializeOpDocumentDescribeEventTopicsInput(v *DescribeEventTopicsInput, value smithyjson.Value) error { 3941 object := value.Object() 3942 defer object.Close() 3943 3944 if v.DirectoryId != nil { 3945 ok := object.Key("DirectoryId") 3946 ok.String(*v.DirectoryId) 3947 } 3948 3949 if v.TopicNames != nil { 3950 ok := object.Key("TopicNames") 3951 if err := awsAwsjson11_serializeDocumentTopicNames(v.TopicNames, ok); err != nil { 3952 return err 3953 } 3954 } 3955 3956 return nil 3957} 3958 3959func awsAwsjson11_serializeOpDocumentDescribeLDAPSSettingsInput(v *DescribeLDAPSSettingsInput, value smithyjson.Value) error { 3960 object := value.Object() 3961 defer object.Close() 3962 3963 if v.DirectoryId != nil { 3964 ok := object.Key("DirectoryId") 3965 ok.String(*v.DirectoryId) 3966 } 3967 3968 if v.Limit != nil { 3969 ok := object.Key("Limit") 3970 ok.Integer(*v.Limit) 3971 } 3972 3973 if v.NextToken != nil { 3974 ok := object.Key("NextToken") 3975 ok.String(*v.NextToken) 3976 } 3977 3978 if len(v.Type) > 0 { 3979 ok := object.Key("Type") 3980 ok.String(string(v.Type)) 3981 } 3982 3983 return nil 3984} 3985 3986func awsAwsjson11_serializeOpDocumentDescribeRegionsInput(v *DescribeRegionsInput, value smithyjson.Value) error { 3987 object := value.Object() 3988 defer object.Close() 3989 3990 if v.DirectoryId != nil { 3991 ok := object.Key("DirectoryId") 3992 ok.String(*v.DirectoryId) 3993 } 3994 3995 if v.NextToken != nil { 3996 ok := object.Key("NextToken") 3997 ok.String(*v.NextToken) 3998 } 3999 4000 if v.RegionName != nil { 4001 ok := object.Key("RegionName") 4002 ok.String(*v.RegionName) 4003 } 4004 4005 return nil 4006} 4007 4008func awsAwsjson11_serializeOpDocumentDescribeSharedDirectoriesInput(v *DescribeSharedDirectoriesInput, value smithyjson.Value) error { 4009 object := value.Object() 4010 defer object.Close() 4011 4012 if v.Limit != nil { 4013 ok := object.Key("Limit") 4014 ok.Integer(*v.Limit) 4015 } 4016 4017 if v.NextToken != nil { 4018 ok := object.Key("NextToken") 4019 ok.String(*v.NextToken) 4020 } 4021 4022 if v.OwnerDirectoryId != nil { 4023 ok := object.Key("OwnerDirectoryId") 4024 ok.String(*v.OwnerDirectoryId) 4025 } 4026 4027 if v.SharedDirectoryIds != nil { 4028 ok := object.Key("SharedDirectoryIds") 4029 if err := awsAwsjson11_serializeDocumentDirectoryIds(v.SharedDirectoryIds, ok); err != nil { 4030 return err 4031 } 4032 } 4033 4034 return nil 4035} 4036 4037func awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(v *DescribeSnapshotsInput, value smithyjson.Value) error { 4038 object := value.Object() 4039 defer object.Close() 4040 4041 if v.DirectoryId != nil { 4042 ok := object.Key("DirectoryId") 4043 ok.String(*v.DirectoryId) 4044 } 4045 4046 if v.Limit != nil { 4047 ok := object.Key("Limit") 4048 ok.Integer(*v.Limit) 4049 } 4050 4051 if v.NextToken != nil { 4052 ok := object.Key("NextToken") 4053 ok.String(*v.NextToken) 4054 } 4055 4056 if v.SnapshotIds != nil { 4057 ok := object.Key("SnapshotIds") 4058 if err := awsAwsjson11_serializeDocumentSnapshotIds(v.SnapshotIds, ok); err != nil { 4059 return err 4060 } 4061 } 4062 4063 return nil 4064} 4065 4066func awsAwsjson11_serializeOpDocumentDescribeTrustsInput(v *DescribeTrustsInput, value smithyjson.Value) error { 4067 object := value.Object() 4068 defer object.Close() 4069 4070 if v.DirectoryId != nil { 4071 ok := object.Key("DirectoryId") 4072 ok.String(*v.DirectoryId) 4073 } 4074 4075 if v.Limit != nil { 4076 ok := object.Key("Limit") 4077 ok.Integer(*v.Limit) 4078 } 4079 4080 if v.NextToken != nil { 4081 ok := object.Key("NextToken") 4082 ok.String(*v.NextToken) 4083 } 4084 4085 if v.TrustIds != nil { 4086 ok := object.Key("TrustIds") 4087 if err := awsAwsjson11_serializeDocumentTrustIds(v.TrustIds, ok); err != nil { 4088 return err 4089 } 4090 } 4091 4092 return nil 4093} 4094 4095func awsAwsjson11_serializeOpDocumentDisableClientAuthenticationInput(v *DisableClientAuthenticationInput, value smithyjson.Value) error { 4096 object := value.Object() 4097 defer object.Close() 4098 4099 if v.DirectoryId != nil { 4100 ok := object.Key("DirectoryId") 4101 ok.String(*v.DirectoryId) 4102 } 4103 4104 if len(v.Type) > 0 { 4105 ok := object.Key("Type") 4106 ok.String(string(v.Type)) 4107 } 4108 4109 return nil 4110} 4111 4112func awsAwsjson11_serializeOpDocumentDisableLDAPSInput(v *DisableLDAPSInput, value smithyjson.Value) error { 4113 object := value.Object() 4114 defer object.Close() 4115 4116 if v.DirectoryId != nil { 4117 ok := object.Key("DirectoryId") 4118 ok.String(*v.DirectoryId) 4119 } 4120 4121 if len(v.Type) > 0 { 4122 ok := object.Key("Type") 4123 ok.String(string(v.Type)) 4124 } 4125 4126 return nil 4127} 4128 4129func awsAwsjson11_serializeOpDocumentDisableRadiusInput(v *DisableRadiusInput, value smithyjson.Value) error { 4130 object := value.Object() 4131 defer object.Close() 4132 4133 if v.DirectoryId != nil { 4134 ok := object.Key("DirectoryId") 4135 ok.String(*v.DirectoryId) 4136 } 4137 4138 return nil 4139} 4140 4141func awsAwsjson11_serializeOpDocumentDisableSsoInput(v *DisableSsoInput, value smithyjson.Value) error { 4142 object := value.Object() 4143 defer object.Close() 4144 4145 if v.DirectoryId != nil { 4146 ok := object.Key("DirectoryId") 4147 ok.String(*v.DirectoryId) 4148 } 4149 4150 if v.Password != nil { 4151 ok := object.Key("Password") 4152 ok.String(*v.Password) 4153 } 4154 4155 if v.UserName != nil { 4156 ok := object.Key("UserName") 4157 ok.String(*v.UserName) 4158 } 4159 4160 return nil 4161} 4162 4163func awsAwsjson11_serializeOpDocumentEnableClientAuthenticationInput(v *EnableClientAuthenticationInput, value smithyjson.Value) error { 4164 object := value.Object() 4165 defer object.Close() 4166 4167 if v.DirectoryId != nil { 4168 ok := object.Key("DirectoryId") 4169 ok.String(*v.DirectoryId) 4170 } 4171 4172 if len(v.Type) > 0 { 4173 ok := object.Key("Type") 4174 ok.String(string(v.Type)) 4175 } 4176 4177 return nil 4178} 4179 4180func awsAwsjson11_serializeOpDocumentEnableLDAPSInput(v *EnableLDAPSInput, value smithyjson.Value) error { 4181 object := value.Object() 4182 defer object.Close() 4183 4184 if v.DirectoryId != nil { 4185 ok := object.Key("DirectoryId") 4186 ok.String(*v.DirectoryId) 4187 } 4188 4189 if len(v.Type) > 0 { 4190 ok := object.Key("Type") 4191 ok.String(string(v.Type)) 4192 } 4193 4194 return nil 4195} 4196 4197func awsAwsjson11_serializeOpDocumentEnableRadiusInput(v *EnableRadiusInput, value smithyjson.Value) error { 4198 object := value.Object() 4199 defer object.Close() 4200 4201 if v.DirectoryId != nil { 4202 ok := object.Key("DirectoryId") 4203 ok.String(*v.DirectoryId) 4204 } 4205 4206 if v.RadiusSettings != nil { 4207 ok := object.Key("RadiusSettings") 4208 if err := awsAwsjson11_serializeDocumentRadiusSettings(v.RadiusSettings, ok); err != nil { 4209 return err 4210 } 4211 } 4212 4213 return nil 4214} 4215 4216func awsAwsjson11_serializeOpDocumentEnableSsoInput(v *EnableSsoInput, value smithyjson.Value) error { 4217 object := value.Object() 4218 defer object.Close() 4219 4220 if v.DirectoryId != nil { 4221 ok := object.Key("DirectoryId") 4222 ok.String(*v.DirectoryId) 4223 } 4224 4225 if v.Password != nil { 4226 ok := object.Key("Password") 4227 ok.String(*v.Password) 4228 } 4229 4230 if v.UserName != nil { 4231 ok := object.Key("UserName") 4232 ok.String(*v.UserName) 4233 } 4234 4235 return nil 4236} 4237 4238func awsAwsjson11_serializeOpDocumentGetDirectoryLimitsInput(v *GetDirectoryLimitsInput, value smithyjson.Value) error { 4239 object := value.Object() 4240 defer object.Close() 4241 4242 return nil 4243} 4244 4245func awsAwsjson11_serializeOpDocumentGetSnapshotLimitsInput(v *GetSnapshotLimitsInput, value smithyjson.Value) error { 4246 object := value.Object() 4247 defer object.Close() 4248 4249 if v.DirectoryId != nil { 4250 ok := object.Key("DirectoryId") 4251 ok.String(*v.DirectoryId) 4252 } 4253 4254 return nil 4255} 4256 4257func awsAwsjson11_serializeOpDocumentListCertificatesInput(v *ListCertificatesInput, value smithyjson.Value) error { 4258 object := value.Object() 4259 defer object.Close() 4260 4261 if v.DirectoryId != nil { 4262 ok := object.Key("DirectoryId") 4263 ok.String(*v.DirectoryId) 4264 } 4265 4266 if v.Limit != nil { 4267 ok := object.Key("Limit") 4268 ok.Integer(*v.Limit) 4269 } 4270 4271 if v.NextToken != nil { 4272 ok := object.Key("NextToken") 4273 ok.String(*v.NextToken) 4274 } 4275 4276 return nil 4277} 4278 4279func awsAwsjson11_serializeOpDocumentListIpRoutesInput(v *ListIpRoutesInput, value smithyjson.Value) error { 4280 object := value.Object() 4281 defer object.Close() 4282 4283 if v.DirectoryId != nil { 4284 ok := object.Key("DirectoryId") 4285 ok.String(*v.DirectoryId) 4286 } 4287 4288 if v.Limit != nil { 4289 ok := object.Key("Limit") 4290 ok.Integer(*v.Limit) 4291 } 4292 4293 if v.NextToken != nil { 4294 ok := object.Key("NextToken") 4295 ok.String(*v.NextToken) 4296 } 4297 4298 return nil 4299} 4300 4301func awsAwsjson11_serializeOpDocumentListLogSubscriptionsInput(v *ListLogSubscriptionsInput, value smithyjson.Value) error { 4302 object := value.Object() 4303 defer object.Close() 4304 4305 if v.DirectoryId != nil { 4306 ok := object.Key("DirectoryId") 4307 ok.String(*v.DirectoryId) 4308 } 4309 4310 if v.Limit != nil { 4311 ok := object.Key("Limit") 4312 ok.Integer(*v.Limit) 4313 } 4314 4315 if v.NextToken != nil { 4316 ok := object.Key("NextToken") 4317 ok.String(*v.NextToken) 4318 } 4319 4320 return nil 4321} 4322 4323func awsAwsjson11_serializeOpDocumentListSchemaExtensionsInput(v *ListSchemaExtensionsInput, value smithyjson.Value) error { 4324 object := value.Object() 4325 defer object.Close() 4326 4327 if v.DirectoryId != nil { 4328 ok := object.Key("DirectoryId") 4329 ok.String(*v.DirectoryId) 4330 } 4331 4332 if v.Limit != nil { 4333 ok := object.Key("Limit") 4334 ok.Integer(*v.Limit) 4335 } 4336 4337 if v.NextToken != nil { 4338 ok := object.Key("NextToken") 4339 ok.String(*v.NextToken) 4340 } 4341 4342 return nil 4343} 4344 4345func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error { 4346 object := value.Object() 4347 defer object.Close() 4348 4349 if v.Limit != nil { 4350 ok := object.Key("Limit") 4351 ok.Integer(*v.Limit) 4352 } 4353 4354 if v.NextToken != nil { 4355 ok := object.Key("NextToken") 4356 ok.String(*v.NextToken) 4357 } 4358 4359 if v.ResourceId != nil { 4360 ok := object.Key("ResourceId") 4361 ok.String(*v.ResourceId) 4362 } 4363 4364 return nil 4365} 4366 4367func awsAwsjson11_serializeOpDocumentRegisterCertificateInput(v *RegisterCertificateInput, value smithyjson.Value) error { 4368 object := value.Object() 4369 defer object.Close() 4370 4371 if v.CertificateData != nil { 4372 ok := object.Key("CertificateData") 4373 ok.String(*v.CertificateData) 4374 } 4375 4376 if v.ClientCertAuthSettings != nil { 4377 ok := object.Key("ClientCertAuthSettings") 4378 if err := awsAwsjson11_serializeDocumentClientCertAuthSettings(v.ClientCertAuthSettings, ok); err != nil { 4379 return err 4380 } 4381 } 4382 4383 if v.DirectoryId != nil { 4384 ok := object.Key("DirectoryId") 4385 ok.String(*v.DirectoryId) 4386 } 4387 4388 if len(v.Type) > 0 { 4389 ok := object.Key("Type") 4390 ok.String(string(v.Type)) 4391 } 4392 4393 return nil 4394} 4395 4396func awsAwsjson11_serializeOpDocumentRegisterEventTopicInput(v *RegisterEventTopicInput, value smithyjson.Value) error { 4397 object := value.Object() 4398 defer object.Close() 4399 4400 if v.DirectoryId != nil { 4401 ok := object.Key("DirectoryId") 4402 ok.String(*v.DirectoryId) 4403 } 4404 4405 if v.TopicName != nil { 4406 ok := object.Key("TopicName") 4407 ok.String(*v.TopicName) 4408 } 4409 4410 return nil 4411} 4412 4413func awsAwsjson11_serializeOpDocumentRejectSharedDirectoryInput(v *RejectSharedDirectoryInput, value smithyjson.Value) error { 4414 object := value.Object() 4415 defer object.Close() 4416 4417 if v.SharedDirectoryId != nil { 4418 ok := object.Key("SharedDirectoryId") 4419 ok.String(*v.SharedDirectoryId) 4420 } 4421 4422 return nil 4423} 4424 4425func awsAwsjson11_serializeOpDocumentRemoveIpRoutesInput(v *RemoveIpRoutesInput, value smithyjson.Value) error { 4426 object := value.Object() 4427 defer object.Close() 4428 4429 if v.CidrIps != nil { 4430 ok := object.Key("CidrIps") 4431 if err := awsAwsjson11_serializeDocumentCidrIps(v.CidrIps, ok); err != nil { 4432 return err 4433 } 4434 } 4435 4436 if v.DirectoryId != nil { 4437 ok := object.Key("DirectoryId") 4438 ok.String(*v.DirectoryId) 4439 } 4440 4441 return nil 4442} 4443 4444func awsAwsjson11_serializeOpDocumentRemoveRegionInput(v *RemoveRegionInput, value smithyjson.Value) error { 4445 object := value.Object() 4446 defer object.Close() 4447 4448 if v.DirectoryId != nil { 4449 ok := object.Key("DirectoryId") 4450 ok.String(*v.DirectoryId) 4451 } 4452 4453 return nil 4454} 4455 4456func awsAwsjson11_serializeOpDocumentRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput, value smithyjson.Value) error { 4457 object := value.Object() 4458 defer object.Close() 4459 4460 if v.ResourceId != nil { 4461 ok := object.Key("ResourceId") 4462 ok.String(*v.ResourceId) 4463 } 4464 4465 if v.TagKeys != nil { 4466 ok := object.Key("TagKeys") 4467 if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil { 4468 return err 4469 } 4470 } 4471 4472 return nil 4473} 4474 4475func awsAwsjson11_serializeOpDocumentResetUserPasswordInput(v *ResetUserPasswordInput, value smithyjson.Value) error { 4476 object := value.Object() 4477 defer object.Close() 4478 4479 if v.DirectoryId != nil { 4480 ok := object.Key("DirectoryId") 4481 ok.String(*v.DirectoryId) 4482 } 4483 4484 if v.NewPassword != nil { 4485 ok := object.Key("NewPassword") 4486 ok.String(*v.NewPassword) 4487 } 4488 4489 if v.UserName != nil { 4490 ok := object.Key("UserName") 4491 ok.String(*v.UserName) 4492 } 4493 4494 return nil 4495} 4496 4497func awsAwsjson11_serializeOpDocumentRestoreFromSnapshotInput(v *RestoreFromSnapshotInput, value smithyjson.Value) error { 4498 object := value.Object() 4499 defer object.Close() 4500 4501 if v.SnapshotId != nil { 4502 ok := object.Key("SnapshotId") 4503 ok.String(*v.SnapshotId) 4504 } 4505 4506 return nil 4507} 4508 4509func awsAwsjson11_serializeOpDocumentShareDirectoryInput(v *ShareDirectoryInput, value smithyjson.Value) error { 4510 object := value.Object() 4511 defer object.Close() 4512 4513 if v.DirectoryId != nil { 4514 ok := object.Key("DirectoryId") 4515 ok.String(*v.DirectoryId) 4516 } 4517 4518 if len(v.ShareMethod) > 0 { 4519 ok := object.Key("ShareMethod") 4520 ok.String(string(v.ShareMethod)) 4521 } 4522 4523 if v.ShareNotes != nil { 4524 ok := object.Key("ShareNotes") 4525 ok.String(*v.ShareNotes) 4526 } 4527 4528 if v.ShareTarget != nil { 4529 ok := object.Key("ShareTarget") 4530 if err := awsAwsjson11_serializeDocumentShareTarget(v.ShareTarget, ok); err != nil { 4531 return err 4532 } 4533 } 4534 4535 return nil 4536} 4537 4538func awsAwsjson11_serializeOpDocumentStartSchemaExtensionInput(v *StartSchemaExtensionInput, value smithyjson.Value) error { 4539 object := value.Object() 4540 defer object.Close() 4541 4542 { 4543 ok := object.Key("CreateSnapshotBeforeSchemaExtension") 4544 ok.Boolean(v.CreateSnapshotBeforeSchemaExtension) 4545 } 4546 4547 if v.Description != nil { 4548 ok := object.Key("Description") 4549 ok.String(*v.Description) 4550 } 4551 4552 if v.DirectoryId != nil { 4553 ok := object.Key("DirectoryId") 4554 ok.String(*v.DirectoryId) 4555 } 4556 4557 if v.LdifContent != nil { 4558 ok := object.Key("LdifContent") 4559 ok.String(*v.LdifContent) 4560 } 4561 4562 return nil 4563} 4564 4565func awsAwsjson11_serializeOpDocumentUnshareDirectoryInput(v *UnshareDirectoryInput, value smithyjson.Value) error { 4566 object := value.Object() 4567 defer object.Close() 4568 4569 if v.DirectoryId != nil { 4570 ok := object.Key("DirectoryId") 4571 ok.String(*v.DirectoryId) 4572 } 4573 4574 if v.UnshareTarget != nil { 4575 ok := object.Key("UnshareTarget") 4576 if err := awsAwsjson11_serializeDocumentUnshareTarget(v.UnshareTarget, ok); err != nil { 4577 return err 4578 } 4579 } 4580 4581 return nil 4582} 4583 4584func awsAwsjson11_serializeOpDocumentUpdateConditionalForwarderInput(v *UpdateConditionalForwarderInput, value smithyjson.Value) error { 4585 object := value.Object() 4586 defer object.Close() 4587 4588 if v.DirectoryId != nil { 4589 ok := object.Key("DirectoryId") 4590 ok.String(*v.DirectoryId) 4591 } 4592 4593 if v.DnsIpAddrs != nil { 4594 ok := object.Key("DnsIpAddrs") 4595 if err := awsAwsjson11_serializeDocumentDnsIpAddrs(v.DnsIpAddrs, ok); err != nil { 4596 return err 4597 } 4598 } 4599 4600 if v.RemoteDomainName != nil { 4601 ok := object.Key("RemoteDomainName") 4602 ok.String(*v.RemoteDomainName) 4603 } 4604 4605 return nil 4606} 4607 4608func awsAwsjson11_serializeOpDocumentUpdateNumberOfDomainControllersInput(v *UpdateNumberOfDomainControllersInput, value smithyjson.Value) error { 4609 object := value.Object() 4610 defer object.Close() 4611 4612 { 4613 ok := object.Key("DesiredNumber") 4614 ok.Integer(v.DesiredNumber) 4615 } 4616 4617 if v.DirectoryId != nil { 4618 ok := object.Key("DirectoryId") 4619 ok.String(*v.DirectoryId) 4620 } 4621 4622 return nil 4623} 4624 4625func awsAwsjson11_serializeOpDocumentUpdateRadiusInput(v *UpdateRadiusInput, value smithyjson.Value) error { 4626 object := value.Object() 4627 defer object.Close() 4628 4629 if v.DirectoryId != nil { 4630 ok := object.Key("DirectoryId") 4631 ok.String(*v.DirectoryId) 4632 } 4633 4634 if v.RadiusSettings != nil { 4635 ok := object.Key("RadiusSettings") 4636 if err := awsAwsjson11_serializeDocumentRadiusSettings(v.RadiusSettings, ok); err != nil { 4637 return err 4638 } 4639 } 4640 4641 return nil 4642} 4643 4644func awsAwsjson11_serializeOpDocumentUpdateTrustInput(v *UpdateTrustInput, value smithyjson.Value) error { 4645 object := value.Object() 4646 defer object.Close() 4647 4648 if len(v.SelectiveAuth) > 0 { 4649 ok := object.Key("SelectiveAuth") 4650 ok.String(string(v.SelectiveAuth)) 4651 } 4652 4653 if v.TrustId != nil { 4654 ok := object.Key("TrustId") 4655 ok.String(*v.TrustId) 4656 } 4657 4658 return nil 4659} 4660 4661func awsAwsjson11_serializeOpDocumentVerifyTrustInput(v *VerifyTrustInput, value smithyjson.Value) error { 4662 object := value.Object() 4663 defer object.Close() 4664 4665 if v.TrustId != nil { 4666 ok := object.Key("TrustId") 4667 ok.String(*v.TrustId) 4668 } 4669 4670 return nil 4671} 4672