1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ecs 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/ecs/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 smithytime "github.com/aws/smithy-go/time" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16) 17 18type awsAwsjson11_serializeOpCreateCapacityProvider struct { 19} 20 21func (*awsAwsjson11_serializeOpCreateCapacityProvider) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsAwsjson11_serializeOpCreateCapacityProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27) { 28 request, ok := in.Request.(*smithyhttp.Request) 29 if !ok { 30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 31 } 32 33 input, ok := in.Parameters.(*CreateCapacityProviderInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 request.Request.URL.Path = "/" 40 request.Request.Method = "POST" 41 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 42 if err != nil { 43 return out, metadata, &smithy.SerializationError{Err: err} 44 } 45 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 46 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.CreateCapacityProvider") 47 48 jsonEncoder := smithyjson.NewEncoder() 49 if err := awsAwsjson11_serializeOpDocumentCreateCapacityProviderInput(input, jsonEncoder.Value); err != nil { 50 return out, metadata, &smithy.SerializationError{Err: err} 51 } 52 53 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 54 return out, metadata, &smithy.SerializationError{Err: err} 55 } 56 57 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 58 return out, metadata, &smithy.SerializationError{Err: err} 59 } 60 in.Request = request 61 62 return next.HandleSerialize(ctx, in) 63} 64 65type awsAwsjson11_serializeOpCreateCluster struct { 66} 67 68func (*awsAwsjson11_serializeOpCreateCluster) ID() string { 69 return "OperationSerializer" 70} 71 72func (m *awsAwsjson11_serializeOpCreateCluster) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 73 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 74) { 75 request, ok := in.Request.(*smithyhttp.Request) 76 if !ok { 77 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 78 } 79 80 input, ok := in.Parameters.(*CreateClusterInput) 81 _ = input 82 if !ok { 83 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 84 } 85 86 request.Request.URL.Path = "/" 87 request.Request.Method = "POST" 88 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 89 if err != nil { 90 return out, metadata, &smithy.SerializationError{Err: err} 91 } 92 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 93 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.CreateCluster") 94 95 jsonEncoder := smithyjson.NewEncoder() 96 if err := awsAwsjson11_serializeOpDocumentCreateClusterInput(input, jsonEncoder.Value); err != nil { 97 return out, metadata, &smithy.SerializationError{Err: err} 98 } 99 100 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 101 return out, metadata, &smithy.SerializationError{Err: err} 102 } 103 104 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 105 return out, metadata, &smithy.SerializationError{Err: err} 106 } 107 in.Request = request 108 109 return next.HandleSerialize(ctx, in) 110} 111 112type awsAwsjson11_serializeOpCreateService struct { 113} 114 115func (*awsAwsjson11_serializeOpCreateService) ID() string { 116 return "OperationSerializer" 117} 118 119func (m *awsAwsjson11_serializeOpCreateService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 120 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 121) { 122 request, ok := in.Request.(*smithyhttp.Request) 123 if !ok { 124 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 125 } 126 127 input, ok := in.Parameters.(*CreateServiceInput) 128 _ = input 129 if !ok { 130 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 131 } 132 133 request.Request.URL.Path = "/" 134 request.Request.Method = "POST" 135 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 136 if err != nil { 137 return out, metadata, &smithy.SerializationError{Err: err} 138 } 139 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 140 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.CreateService") 141 142 jsonEncoder := smithyjson.NewEncoder() 143 if err := awsAwsjson11_serializeOpDocumentCreateServiceInput(input, jsonEncoder.Value); err != nil { 144 return out, metadata, &smithy.SerializationError{Err: err} 145 } 146 147 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 148 return out, metadata, &smithy.SerializationError{Err: err} 149 } 150 151 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 152 return out, metadata, &smithy.SerializationError{Err: err} 153 } 154 in.Request = request 155 156 return next.HandleSerialize(ctx, in) 157} 158 159type awsAwsjson11_serializeOpCreateTaskSet struct { 160} 161 162func (*awsAwsjson11_serializeOpCreateTaskSet) ID() string { 163 return "OperationSerializer" 164} 165 166func (m *awsAwsjson11_serializeOpCreateTaskSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 167 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 168) { 169 request, ok := in.Request.(*smithyhttp.Request) 170 if !ok { 171 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 172 } 173 174 input, ok := in.Parameters.(*CreateTaskSetInput) 175 _ = input 176 if !ok { 177 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 178 } 179 180 request.Request.URL.Path = "/" 181 request.Request.Method = "POST" 182 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 183 if err != nil { 184 return out, metadata, &smithy.SerializationError{Err: err} 185 } 186 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 187 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.CreateTaskSet") 188 189 jsonEncoder := smithyjson.NewEncoder() 190 if err := awsAwsjson11_serializeOpDocumentCreateTaskSetInput(input, jsonEncoder.Value); err != nil { 191 return out, metadata, &smithy.SerializationError{Err: err} 192 } 193 194 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 195 return out, metadata, &smithy.SerializationError{Err: err} 196 } 197 198 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 199 return out, metadata, &smithy.SerializationError{Err: err} 200 } 201 in.Request = request 202 203 return next.HandleSerialize(ctx, in) 204} 205 206type awsAwsjson11_serializeOpDeleteAccountSetting struct { 207} 208 209func (*awsAwsjson11_serializeOpDeleteAccountSetting) ID() string { 210 return "OperationSerializer" 211} 212 213func (m *awsAwsjson11_serializeOpDeleteAccountSetting) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 214 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 215) { 216 request, ok := in.Request.(*smithyhttp.Request) 217 if !ok { 218 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 219 } 220 221 input, ok := in.Parameters.(*DeleteAccountSettingInput) 222 _ = input 223 if !ok { 224 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 225 } 226 227 request.Request.URL.Path = "/" 228 request.Request.Method = "POST" 229 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 230 if err != nil { 231 return out, metadata, &smithy.SerializationError{Err: err} 232 } 233 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 234 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeleteAccountSetting") 235 236 jsonEncoder := smithyjson.NewEncoder() 237 if err := awsAwsjson11_serializeOpDocumentDeleteAccountSettingInput(input, jsonEncoder.Value); err != nil { 238 return out, metadata, &smithy.SerializationError{Err: err} 239 } 240 241 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 242 return out, metadata, &smithy.SerializationError{Err: err} 243 } 244 245 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 246 return out, metadata, &smithy.SerializationError{Err: err} 247 } 248 in.Request = request 249 250 return next.HandleSerialize(ctx, in) 251} 252 253type awsAwsjson11_serializeOpDeleteAttributes struct { 254} 255 256func (*awsAwsjson11_serializeOpDeleteAttributes) ID() string { 257 return "OperationSerializer" 258} 259 260func (m *awsAwsjson11_serializeOpDeleteAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 261 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 262) { 263 request, ok := in.Request.(*smithyhttp.Request) 264 if !ok { 265 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 266 } 267 268 input, ok := in.Parameters.(*DeleteAttributesInput) 269 _ = input 270 if !ok { 271 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 272 } 273 274 request.Request.URL.Path = "/" 275 request.Request.Method = "POST" 276 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 277 if err != nil { 278 return out, metadata, &smithy.SerializationError{Err: err} 279 } 280 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 281 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeleteAttributes") 282 283 jsonEncoder := smithyjson.NewEncoder() 284 if err := awsAwsjson11_serializeOpDocumentDeleteAttributesInput(input, jsonEncoder.Value); err != nil { 285 return out, metadata, &smithy.SerializationError{Err: err} 286 } 287 288 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 289 return out, metadata, &smithy.SerializationError{Err: err} 290 } 291 292 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 293 return out, metadata, &smithy.SerializationError{Err: err} 294 } 295 in.Request = request 296 297 return next.HandleSerialize(ctx, in) 298} 299 300type awsAwsjson11_serializeOpDeleteCapacityProvider struct { 301} 302 303func (*awsAwsjson11_serializeOpDeleteCapacityProvider) ID() string { 304 return "OperationSerializer" 305} 306 307func (m *awsAwsjson11_serializeOpDeleteCapacityProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 308 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 309) { 310 request, ok := in.Request.(*smithyhttp.Request) 311 if !ok { 312 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 313 } 314 315 input, ok := in.Parameters.(*DeleteCapacityProviderInput) 316 _ = input 317 if !ok { 318 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 319 } 320 321 request.Request.URL.Path = "/" 322 request.Request.Method = "POST" 323 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 324 if err != nil { 325 return out, metadata, &smithy.SerializationError{Err: err} 326 } 327 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 328 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeleteCapacityProvider") 329 330 jsonEncoder := smithyjson.NewEncoder() 331 if err := awsAwsjson11_serializeOpDocumentDeleteCapacityProviderInput(input, jsonEncoder.Value); err != nil { 332 return out, metadata, &smithy.SerializationError{Err: err} 333 } 334 335 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 336 return out, metadata, &smithy.SerializationError{Err: err} 337 } 338 339 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 340 return out, metadata, &smithy.SerializationError{Err: err} 341 } 342 in.Request = request 343 344 return next.HandleSerialize(ctx, in) 345} 346 347type awsAwsjson11_serializeOpDeleteCluster struct { 348} 349 350func (*awsAwsjson11_serializeOpDeleteCluster) ID() string { 351 return "OperationSerializer" 352} 353 354func (m *awsAwsjson11_serializeOpDeleteCluster) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 355 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 356) { 357 request, ok := in.Request.(*smithyhttp.Request) 358 if !ok { 359 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 360 } 361 362 input, ok := in.Parameters.(*DeleteClusterInput) 363 _ = input 364 if !ok { 365 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 366 } 367 368 request.Request.URL.Path = "/" 369 request.Request.Method = "POST" 370 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 371 if err != nil { 372 return out, metadata, &smithy.SerializationError{Err: err} 373 } 374 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 375 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeleteCluster") 376 377 jsonEncoder := smithyjson.NewEncoder() 378 if err := awsAwsjson11_serializeOpDocumentDeleteClusterInput(input, jsonEncoder.Value); err != nil { 379 return out, metadata, &smithy.SerializationError{Err: err} 380 } 381 382 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 383 return out, metadata, &smithy.SerializationError{Err: err} 384 } 385 386 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 387 return out, metadata, &smithy.SerializationError{Err: err} 388 } 389 in.Request = request 390 391 return next.HandleSerialize(ctx, in) 392} 393 394type awsAwsjson11_serializeOpDeleteService struct { 395} 396 397func (*awsAwsjson11_serializeOpDeleteService) ID() string { 398 return "OperationSerializer" 399} 400 401func (m *awsAwsjson11_serializeOpDeleteService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 402 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 403) { 404 request, ok := in.Request.(*smithyhttp.Request) 405 if !ok { 406 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 407 } 408 409 input, ok := in.Parameters.(*DeleteServiceInput) 410 _ = input 411 if !ok { 412 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 413 } 414 415 request.Request.URL.Path = "/" 416 request.Request.Method = "POST" 417 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 418 if err != nil { 419 return out, metadata, &smithy.SerializationError{Err: err} 420 } 421 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 422 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeleteService") 423 424 jsonEncoder := smithyjson.NewEncoder() 425 if err := awsAwsjson11_serializeOpDocumentDeleteServiceInput(input, jsonEncoder.Value); err != nil { 426 return out, metadata, &smithy.SerializationError{Err: err} 427 } 428 429 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 430 return out, metadata, &smithy.SerializationError{Err: err} 431 } 432 433 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 434 return out, metadata, &smithy.SerializationError{Err: err} 435 } 436 in.Request = request 437 438 return next.HandleSerialize(ctx, in) 439} 440 441type awsAwsjson11_serializeOpDeleteTaskSet struct { 442} 443 444func (*awsAwsjson11_serializeOpDeleteTaskSet) ID() string { 445 return "OperationSerializer" 446} 447 448func (m *awsAwsjson11_serializeOpDeleteTaskSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 449 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 450) { 451 request, ok := in.Request.(*smithyhttp.Request) 452 if !ok { 453 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 454 } 455 456 input, ok := in.Parameters.(*DeleteTaskSetInput) 457 _ = input 458 if !ok { 459 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 460 } 461 462 request.Request.URL.Path = "/" 463 request.Request.Method = "POST" 464 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 465 if err != nil { 466 return out, metadata, &smithy.SerializationError{Err: err} 467 } 468 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 469 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeleteTaskSet") 470 471 jsonEncoder := smithyjson.NewEncoder() 472 if err := awsAwsjson11_serializeOpDocumentDeleteTaskSetInput(input, jsonEncoder.Value); err != nil { 473 return out, metadata, &smithy.SerializationError{Err: err} 474 } 475 476 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 477 return out, metadata, &smithy.SerializationError{Err: err} 478 } 479 480 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 481 return out, metadata, &smithy.SerializationError{Err: err} 482 } 483 in.Request = request 484 485 return next.HandleSerialize(ctx, in) 486} 487 488type awsAwsjson11_serializeOpDeregisterContainerInstance struct { 489} 490 491func (*awsAwsjson11_serializeOpDeregisterContainerInstance) ID() string { 492 return "OperationSerializer" 493} 494 495func (m *awsAwsjson11_serializeOpDeregisterContainerInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 496 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 497) { 498 request, ok := in.Request.(*smithyhttp.Request) 499 if !ok { 500 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 501 } 502 503 input, ok := in.Parameters.(*DeregisterContainerInstanceInput) 504 _ = input 505 if !ok { 506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 507 } 508 509 request.Request.URL.Path = "/" 510 request.Request.Method = "POST" 511 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 512 if err != nil { 513 return out, metadata, &smithy.SerializationError{Err: err} 514 } 515 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 516 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeregisterContainerInstance") 517 518 jsonEncoder := smithyjson.NewEncoder() 519 if err := awsAwsjson11_serializeOpDocumentDeregisterContainerInstanceInput(input, jsonEncoder.Value); err != nil { 520 return out, metadata, &smithy.SerializationError{Err: err} 521 } 522 523 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 524 return out, metadata, &smithy.SerializationError{Err: err} 525 } 526 527 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 528 return out, metadata, &smithy.SerializationError{Err: err} 529 } 530 in.Request = request 531 532 return next.HandleSerialize(ctx, in) 533} 534 535type awsAwsjson11_serializeOpDeregisterTaskDefinition struct { 536} 537 538func (*awsAwsjson11_serializeOpDeregisterTaskDefinition) ID() string { 539 return "OperationSerializer" 540} 541 542func (m *awsAwsjson11_serializeOpDeregisterTaskDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 543 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 544) { 545 request, ok := in.Request.(*smithyhttp.Request) 546 if !ok { 547 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 548 } 549 550 input, ok := in.Parameters.(*DeregisterTaskDefinitionInput) 551 _ = input 552 if !ok { 553 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 554 } 555 556 request.Request.URL.Path = "/" 557 request.Request.Method = "POST" 558 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 559 if err != nil { 560 return out, metadata, &smithy.SerializationError{Err: err} 561 } 562 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 563 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DeregisterTaskDefinition") 564 565 jsonEncoder := smithyjson.NewEncoder() 566 if err := awsAwsjson11_serializeOpDocumentDeregisterTaskDefinitionInput(input, jsonEncoder.Value); err != nil { 567 return out, metadata, &smithy.SerializationError{Err: err} 568 } 569 570 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 571 return out, metadata, &smithy.SerializationError{Err: err} 572 } 573 574 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 575 return out, metadata, &smithy.SerializationError{Err: err} 576 } 577 in.Request = request 578 579 return next.HandleSerialize(ctx, in) 580} 581 582type awsAwsjson11_serializeOpDescribeCapacityProviders struct { 583} 584 585func (*awsAwsjson11_serializeOpDescribeCapacityProviders) ID() string { 586 return "OperationSerializer" 587} 588 589func (m *awsAwsjson11_serializeOpDescribeCapacityProviders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 590 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 591) { 592 request, ok := in.Request.(*smithyhttp.Request) 593 if !ok { 594 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 595 } 596 597 input, ok := in.Parameters.(*DescribeCapacityProvidersInput) 598 _ = input 599 if !ok { 600 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 601 } 602 603 request.Request.URL.Path = "/" 604 request.Request.Method = "POST" 605 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 606 if err != nil { 607 return out, metadata, &smithy.SerializationError{Err: err} 608 } 609 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 610 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DescribeCapacityProviders") 611 612 jsonEncoder := smithyjson.NewEncoder() 613 if err := awsAwsjson11_serializeOpDocumentDescribeCapacityProvidersInput(input, jsonEncoder.Value); err != nil { 614 return out, metadata, &smithy.SerializationError{Err: err} 615 } 616 617 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 618 return out, metadata, &smithy.SerializationError{Err: err} 619 } 620 621 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 622 return out, metadata, &smithy.SerializationError{Err: err} 623 } 624 in.Request = request 625 626 return next.HandleSerialize(ctx, in) 627} 628 629type awsAwsjson11_serializeOpDescribeClusters struct { 630} 631 632func (*awsAwsjson11_serializeOpDescribeClusters) ID() string { 633 return "OperationSerializer" 634} 635 636func (m *awsAwsjson11_serializeOpDescribeClusters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 637 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 638) { 639 request, ok := in.Request.(*smithyhttp.Request) 640 if !ok { 641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 642 } 643 644 input, ok := in.Parameters.(*DescribeClustersInput) 645 _ = input 646 if !ok { 647 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 648 } 649 650 request.Request.URL.Path = "/" 651 request.Request.Method = "POST" 652 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 653 if err != nil { 654 return out, metadata, &smithy.SerializationError{Err: err} 655 } 656 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 657 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DescribeClusters") 658 659 jsonEncoder := smithyjson.NewEncoder() 660 if err := awsAwsjson11_serializeOpDocumentDescribeClustersInput(input, jsonEncoder.Value); err != nil { 661 return out, metadata, &smithy.SerializationError{Err: err} 662 } 663 664 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 665 return out, metadata, &smithy.SerializationError{Err: err} 666 } 667 668 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 669 return out, metadata, &smithy.SerializationError{Err: err} 670 } 671 in.Request = request 672 673 return next.HandleSerialize(ctx, in) 674} 675 676type awsAwsjson11_serializeOpDescribeContainerInstances struct { 677} 678 679func (*awsAwsjson11_serializeOpDescribeContainerInstances) ID() string { 680 return "OperationSerializer" 681} 682 683func (m *awsAwsjson11_serializeOpDescribeContainerInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 684 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 685) { 686 request, ok := in.Request.(*smithyhttp.Request) 687 if !ok { 688 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 689 } 690 691 input, ok := in.Parameters.(*DescribeContainerInstancesInput) 692 _ = input 693 if !ok { 694 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 695 } 696 697 request.Request.URL.Path = "/" 698 request.Request.Method = "POST" 699 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 700 if err != nil { 701 return out, metadata, &smithy.SerializationError{Err: err} 702 } 703 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 704 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DescribeContainerInstances") 705 706 jsonEncoder := smithyjson.NewEncoder() 707 if err := awsAwsjson11_serializeOpDocumentDescribeContainerInstancesInput(input, jsonEncoder.Value); err != nil { 708 return out, metadata, &smithy.SerializationError{Err: err} 709 } 710 711 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 712 return out, metadata, &smithy.SerializationError{Err: err} 713 } 714 715 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 716 return out, metadata, &smithy.SerializationError{Err: err} 717 } 718 in.Request = request 719 720 return next.HandleSerialize(ctx, in) 721} 722 723type awsAwsjson11_serializeOpDescribeServices struct { 724} 725 726func (*awsAwsjson11_serializeOpDescribeServices) ID() string { 727 return "OperationSerializer" 728} 729 730func (m *awsAwsjson11_serializeOpDescribeServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 731 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 732) { 733 request, ok := in.Request.(*smithyhttp.Request) 734 if !ok { 735 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 736 } 737 738 input, ok := in.Parameters.(*DescribeServicesInput) 739 _ = input 740 if !ok { 741 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 742 } 743 744 request.Request.URL.Path = "/" 745 request.Request.Method = "POST" 746 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 747 if err != nil { 748 return out, metadata, &smithy.SerializationError{Err: err} 749 } 750 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 751 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DescribeServices") 752 753 jsonEncoder := smithyjson.NewEncoder() 754 if err := awsAwsjson11_serializeOpDocumentDescribeServicesInput(input, jsonEncoder.Value); err != nil { 755 return out, metadata, &smithy.SerializationError{Err: err} 756 } 757 758 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 759 return out, metadata, &smithy.SerializationError{Err: err} 760 } 761 762 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 763 return out, metadata, &smithy.SerializationError{Err: err} 764 } 765 in.Request = request 766 767 return next.HandleSerialize(ctx, in) 768} 769 770type awsAwsjson11_serializeOpDescribeTaskDefinition struct { 771} 772 773func (*awsAwsjson11_serializeOpDescribeTaskDefinition) ID() string { 774 return "OperationSerializer" 775} 776 777func (m *awsAwsjson11_serializeOpDescribeTaskDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 778 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 779) { 780 request, ok := in.Request.(*smithyhttp.Request) 781 if !ok { 782 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 783 } 784 785 input, ok := in.Parameters.(*DescribeTaskDefinitionInput) 786 _ = input 787 if !ok { 788 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 789 } 790 791 request.Request.URL.Path = "/" 792 request.Request.Method = "POST" 793 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 794 if err != nil { 795 return out, metadata, &smithy.SerializationError{Err: err} 796 } 797 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 798 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DescribeTaskDefinition") 799 800 jsonEncoder := smithyjson.NewEncoder() 801 if err := awsAwsjson11_serializeOpDocumentDescribeTaskDefinitionInput(input, jsonEncoder.Value); err != nil { 802 return out, metadata, &smithy.SerializationError{Err: err} 803 } 804 805 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 806 return out, metadata, &smithy.SerializationError{Err: err} 807 } 808 809 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 810 return out, metadata, &smithy.SerializationError{Err: err} 811 } 812 in.Request = request 813 814 return next.HandleSerialize(ctx, in) 815} 816 817type awsAwsjson11_serializeOpDescribeTasks struct { 818} 819 820func (*awsAwsjson11_serializeOpDescribeTasks) ID() string { 821 return "OperationSerializer" 822} 823 824func (m *awsAwsjson11_serializeOpDescribeTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 825 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 826) { 827 request, ok := in.Request.(*smithyhttp.Request) 828 if !ok { 829 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 830 } 831 832 input, ok := in.Parameters.(*DescribeTasksInput) 833 _ = input 834 if !ok { 835 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 836 } 837 838 request.Request.URL.Path = "/" 839 request.Request.Method = "POST" 840 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 841 if err != nil { 842 return out, metadata, &smithy.SerializationError{Err: err} 843 } 844 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 845 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DescribeTasks") 846 847 jsonEncoder := smithyjson.NewEncoder() 848 if err := awsAwsjson11_serializeOpDocumentDescribeTasksInput(input, jsonEncoder.Value); err != nil { 849 return out, metadata, &smithy.SerializationError{Err: err} 850 } 851 852 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 853 return out, metadata, &smithy.SerializationError{Err: err} 854 } 855 856 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 857 return out, metadata, &smithy.SerializationError{Err: err} 858 } 859 in.Request = request 860 861 return next.HandleSerialize(ctx, in) 862} 863 864type awsAwsjson11_serializeOpDescribeTaskSets struct { 865} 866 867func (*awsAwsjson11_serializeOpDescribeTaskSets) ID() string { 868 return "OperationSerializer" 869} 870 871func (m *awsAwsjson11_serializeOpDescribeTaskSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 872 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 873) { 874 request, ok := in.Request.(*smithyhttp.Request) 875 if !ok { 876 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 877 } 878 879 input, ok := in.Parameters.(*DescribeTaskSetsInput) 880 _ = input 881 if !ok { 882 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 883 } 884 885 request.Request.URL.Path = "/" 886 request.Request.Method = "POST" 887 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 888 if err != nil { 889 return out, metadata, &smithy.SerializationError{Err: err} 890 } 891 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 892 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DescribeTaskSets") 893 894 jsonEncoder := smithyjson.NewEncoder() 895 if err := awsAwsjson11_serializeOpDocumentDescribeTaskSetsInput(input, jsonEncoder.Value); err != nil { 896 return out, metadata, &smithy.SerializationError{Err: err} 897 } 898 899 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 900 return out, metadata, &smithy.SerializationError{Err: err} 901 } 902 903 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 904 return out, metadata, &smithy.SerializationError{Err: err} 905 } 906 in.Request = request 907 908 return next.HandleSerialize(ctx, in) 909} 910 911type awsAwsjson11_serializeOpDiscoverPollEndpoint struct { 912} 913 914func (*awsAwsjson11_serializeOpDiscoverPollEndpoint) ID() string { 915 return "OperationSerializer" 916} 917 918func (m *awsAwsjson11_serializeOpDiscoverPollEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 919 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 920) { 921 request, ok := in.Request.(*smithyhttp.Request) 922 if !ok { 923 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 924 } 925 926 input, ok := in.Parameters.(*DiscoverPollEndpointInput) 927 _ = input 928 if !ok { 929 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 930 } 931 932 request.Request.URL.Path = "/" 933 request.Request.Method = "POST" 934 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 935 if err != nil { 936 return out, metadata, &smithy.SerializationError{Err: err} 937 } 938 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 939 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.DiscoverPollEndpoint") 940 941 jsonEncoder := smithyjson.NewEncoder() 942 if err := awsAwsjson11_serializeOpDocumentDiscoverPollEndpointInput(input, jsonEncoder.Value); err != nil { 943 return out, metadata, &smithy.SerializationError{Err: err} 944 } 945 946 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 947 return out, metadata, &smithy.SerializationError{Err: err} 948 } 949 950 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 951 return out, metadata, &smithy.SerializationError{Err: err} 952 } 953 in.Request = request 954 955 return next.HandleSerialize(ctx, in) 956} 957 958type awsAwsjson11_serializeOpListAccountSettings struct { 959} 960 961func (*awsAwsjson11_serializeOpListAccountSettings) ID() string { 962 return "OperationSerializer" 963} 964 965func (m *awsAwsjson11_serializeOpListAccountSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 966 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 967) { 968 request, ok := in.Request.(*smithyhttp.Request) 969 if !ok { 970 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 971 } 972 973 input, ok := in.Parameters.(*ListAccountSettingsInput) 974 _ = input 975 if !ok { 976 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 977 } 978 979 request.Request.URL.Path = "/" 980 request.Request.Method = "POST" 981 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 982 if err != nil { 983 return out, metadata, &smithy.SerializationError{Err: err} 984 } 985 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 986 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListAccountSettings") 987 988 jsonEncoder := smithyjson.NewEncoder() 989 if err := awsAwsjson11_serializeOpDocumentListAccountSettingsInput(input, jsonEncoder.Value); err != nil { 990 return out, metadata, &smithy.SerializationError{Err: err} 991 } 992 993 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 994 return out, metadata, &smithy.SerializationError{Err: err} 995 } 996 997 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 998 return out, metadata, &smithy.SerializationError{Err: err} 999 } 1000 in.Request = request 1001 1002 return next.HandleSerialize(ctx, in) 1003} 1004 1005type awsAwsjson11_serializeOpListAttributes struct { 1006} 1007 1008func (*awsAwsjson11_serializeOpListAttributes) ID() string { 1009 return "OperationSerializer" 1010} 1011 1012func (m *awsAwsjson11_serializeOpListAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1013 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1014) { 1015 request, ok := in.Request.(*smithyhttp.Request) 1016 if !ok { 1017 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1018 } 1019 1020 input, ok := in.Parameters.(*ListAttributesInput) 1021 _ = input 1022 if !ok { 1023 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1024 } 1025 1026 request.Request.URL.Path = "/" 1027 request.Request.Method = "POST" 1028 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1029 if err != nil { 1030 return out, metadata, &smithy.SerializationError{Err: err} 1031 } 1032 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1033 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListAttributes") 1034 1035 jsonEncoder := smithyjson.NewEncoder() 1036 if err := awsAwsjson11_serializeOpDocumentListAttributesInput(input, jsonEncoder.Value); err != nil { 1037 return out, metadata, &smithy.SerializationError{Err: err} 1038 } 1039 1040 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1041 return out, metadata, &smithy.SerializationError{Err: err} 1042 } 1043 1044 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1045 return out, metadata, &smithy.SerializationError{Err: err} 1046 } 1047 in.Request = request 1048 1049 return next.HandleSerialize(ctx, in) 1050} 1051 1052type awsAwsjson11_serializeOpListClusters struct { 1053} 1054 1055func (*awsAwsjson11_serializeOpListClusters) ID() string { 1056 return "OperationSerializer" 1057} 1058 1059func (m *awsAwsjson11_serializeOpListClusters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1060 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1061) { 1062 request, ok := in.Request.(*smithyhttp.Request) 1063 if !ok { 1064 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1065 } 1066 1067 input, ok := in.Parameters.(*ListClustersInput) 1068 _ = input 1069 if !ok { 1070 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1071 } 1072 1073 request.Request.URL.Path = "/" 1074 request.Request.Method = "POST" 1075 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1076 if err != nil { 1077 return out, metadata, &smithy.SerializationError{Err: err} 1078 } 1079 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1080 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListClusters") 1081 1082 jsonEncoder := smithyjson.NewEncoder() 1083 if err := awsAwsjson11_serializeOpDocumentListClustersInput(input, jsonEncoder.Value); err != nil { 1084 return out, metadata, &smithy.SerializationError{Err: err} 1085 } 1086 1087 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1088 return out, metadata, &smithy.SerializationError{Err: err} 1089 } 1090 1091 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1092 return out, metadata, &smithy.SerializationError{Err: err} 1093 } 1094 in.Request = request 1095 1096 return next.HandleSerialize(ctx, in) 1097} 1098 1099type awsAwsjson11_serializeOpListContainerInstances struct { 1100} 1101 1102func (*awsAwsjson11_serializeOpListContainerInstances) ID() string { 1103 return "OperationSerializer" 1104} 1105 1106func (m *awsAwsjson11_serializeOpListContainerInstances) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1107 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1108) { 1109 request, ok := in.Request.(*smithyhttp.Request) 1110 if !ok { 1111 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1112 } 1113 1114 input, ok := in.Parameters.(*ListContainerInstancesInput) 1115 _ = input 1116 if !ok { 1117 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1118 } 1119 1120 request.Request.URL.Path = "/" 1121 request.Request.Method = "POST" 1122 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1123 if err != nil { 1124 return out, metadata, &smithy.SerializationError{Err: err} 1125 } 1126 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1127 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListContainerInstances") 1128 1129 jsonEncoder := smithyjson.NewEncoder() 1130 if err := awsAwsjson11_serializeOpDocumentListContainerInstancesInput(input, jsonEncoder.Value); err != nil { 1131 return out, metadata, &smithy.SerializationError{Err: err} 1132 } 1133 1134 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1135 return out, metadata, &smithy.SerializationError{Err: err} 1136 } 1137 1138 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1139 return out, metadata, &smithy.SerializationError{Err: err} 1140 } 1141 in.Request = request 1142 1143 return next.HandleSerialize(ctx, in) 1144} 1145 1146type awsAwsjson11_serializeOpListServices struct { 1147} 1148 1149func (*awsAwsjson11_serializeOpListServices) ID() string { 1150 return "OperationSerializer" 1151} 1152 1153func (m *awsAwsjson11_serializeOpListServices) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1154 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1155) { 1156 request, ok := in.Request.(*smithyhttp.Request) 1157 if !ok { 1158 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1159 } 1160 1161 input, ok := in.Parameters.(*ListServicesInput) 1162 _ = input 1163 if !ok { 1164 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1165 } 1166 1167 request.Request.URL.Path = "/" 1168 request.Request.Method = "POST" 1169 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1170 if err != nil { 1171 return out, metadata, &smithy.SerializationError{Err: err} 1172 } 1173 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1174 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListServices") 1175 1176 jsonEncoder := smithyjson.NewEncoder() 1177 if err := awsAwsjson11_serializeOpDocumentListServicesInput(input, jsonEncoder.Value); err != nil { 1178 return out, metadata, &smithy.SerializationError{Err: err} 1179 } 1180 1181 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1182 return out, metadata, &smithy.SerializationError{Err: err} 1183 } 1184 1185 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1186 return out, metadata, &smithy.SerializationError{Err: err} 1187 } 1188 in.Request = request 1189 1190 return next.HandleSerialize(ctx, in) 1191} 1192 1193type awsAwsjson11_serializeOpListTagsForResource struct { 1194} 1195 1196func (*awsAwsjson11_serializeOpListTagsForResource) ID() string { 1197 return "OperationSerializer" 1198} 1199 1200func (m *awsAwsjson11_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1201 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1202) { 1203 request, ok := in.Request.(*smithyhttp.Request) 1204 if !ok { 1205 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1206 } 1207 1208 input, ok := in.Parameters.(*ListTagsForResourceInput) 1209 _ = input 1210 if !ok { 1211 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1212 } 1213 1214 request.Request.URL.Path = "/" 1215 request.Request.Method = "POST" 1216 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1217 if err != nil { 1218 return out, metadata, &smithy.SerializationError{Err: err} 1219 } 1220 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1221 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListTagsForResource") 1222 1223 jsonEncoder := smithyjson.NewEncoder() 1224 if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil { 1225 return out, metadata, &smithy.SerializationError{Err: err} 1226 } 1227 1228 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1229 return out, metadata, &smithy.SerializationError{Err: err} 1230 } 1231 1232 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1233 return out, metadata, &smithy.SerializationError{Err: err} 1234 } 1235 in.Request = request 1236 1237 return next.HandleSerialize(ctx, in) 1238} 1239 1240type awsAwsjson11_serializeOpListTaskDefinitionFamilies struct { 1241} 1242 1243func (*awsAwsjson11_serializeOpListTaskDefinitionFamilies) ID() string { 1244 return "OperationSerializer" 1245} 1246 1247func (m *awsAwsjson11_serializeOpListTaskDefinitionFamilies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1248 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1249) { 1250 request, ok := in.Request.(*smithyhttp.Request) 1251 if !ok { 1252 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1253 } 1254 1255 input, ok := in.Parameters.(*ListTaskDefinitionFamiliesInput) 1256 _ = input 1257 if !ok { 1258 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1259 } 1260 1261 request.Request.URL.Path = "/" 1262 request.Request.Method = "POST" 1263 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1264 if err != nil { 1265 return out, metadata, &smithy.SerializationError{Err: err} 1266 } 1267 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1268 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListTaskDefinitionFamilies") 1269 1270 jsonEncoder := smithyjson.NewEncoder() 1271 if err := awsAwsjson11_serializeOpDocumentListTaskDefinitionFamiliesInput(input, jsonEncoder.Value); err != nil { 1272 return out, metadata, &smithy.SerializationError{Err: err} 1273 } 1274 1275 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1276 return out, metadata, &smithy.SerializationError{Err: err} 1277 } 1278 1279 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1280 return out, metadata, &smithy.SerializationError{Err: err} 1281 } 1282 in.Request = request 1283 1284 return next.HandleSerialize(ctx, in) 1285} 1286 1287type awsAwsjson11_serializeOpListTaskDefinitions struct { 1288} 1289 1290func (*awsAwsjson11_serializeOpListTaskDefinitions) ID() string { 1291 return "OperationSerializer" 1292} 1293 1294func (m *awsAwsjson11_serializeOpListTaskDefinitions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1295 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1296) { 1297 request, ok := in.Request.(*smithyhttp.Request) 1298 if !ok { 1299 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1300 } 1301 1302 input, ok := in.Parameters.(*ListTaskDefinitionsInput) 1303 _ = input 1304 if !ok { 1305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1306 } 1307 1308 request.Request.URL.Path = "/" 1309 request.Request.Method = "POST" 1310 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1311 if err != nil { 1312 return out, metadata, &smithy.SerializationError{Err: err} 1313 } 1314 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1315 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListTaskDefinitions") 1316 1317 jsonEncoder := smithyjson.NewEncoder() 1318 if err := awsAwsjson11_serializeOpDocumentListTaskDefinitionsInput(input, jsonEncoder.Value); err != nil { 1319 return out, metadata, &smithy.SerializationError{Err: err} 1320 } 1321 1322 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1323 return out, metadata, &smithy.SerializationError{Err: err} 1324 } 1325 1326 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1327 return out, metadata, &smithy.SerializationError{Err: err} 1328 } 1329 in.Request = request 1330 1331 return next.HandleSerialize(ctx, in) 1332} 1333 1334type awsAwsjson11_serializeOpListTasks struct { 1335} 1336 1337func (*awsAwsjson11_serializeOpListTasks) ID() string { 1338 return "OperationSerializer" 1339} 1340 1341func (m *awsAwsjson11_serializeOpListTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1342 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1343) { 1344 request, ok := in.Request.(*smithyhttp.Request) 1345 if !ok { 1346 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1347 } 1348 1349 input, ok := in.Parameters.(*ListTasksInput) 1350 _ = input 1351 if !ok { 1352 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1353 } 1354 1355 request.Request.URL.Path = "/" 1356 request.Request.Method = "POST" 1357 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1358 if err != nil { 1359 return out, metadata, &smithy.SerializationError{Err: err} 1360 } 1361 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1362 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.ListTasks") 1363 1364 jsonEncoder := smithyjson.NewEncoder() 1365 if err := awsAwsjson11_serializeOpDocumentListTasksInput(input, jsonEncoder.Value); err != nil { 1366 return out, metadata, &smithy.SerializationError{Err: err} 1367 } 1368 1369 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1370 return out, metadata, &smithy.SerializationError{Err: err} 1371 } 1372 1373 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1374 return out, metadata, &smithy.SerializationError{Err: err} 1375 } 1376 in.Request = request 1377 1378 return next.HandleSerialize(ctx, in) 1379} 1380 1381type awsAwsjson11_serializeOpPutAccountSetting struct { 1382} 1383 1384func (*awsAwsjson11_serializeOpPutAccountSetting) ID() string { 1385 return "OperationSerializer" 1386} 1387 1388func (m *awsAwsjson11_serializeOpPutAccountSetting) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1389 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1390) { 1391 request, ok := in.Request.(*smithyhttp.Request) 1392 if !ok { 1393 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1394 } 1395 1396 input, ok := in.Parameters.(*PutAccountSettingInput) 1397 _ = input 1398 if !ok { 1399 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1400 } 1401 1402 request.Request.URL.Path = "/" 1403 request.Request.Method = "POST" 1404 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1405 if err != nil { 1406 return out, metadata, &smithy.SerializationError{Err: err} 1407 } 1408 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1409 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.PutAccountSetting") 1410 1411 jsonEncoder := smithyjson.NewEncoder() 1412 if err := awsAwsjson11_serializeOpDocumentPutAccountSettingInput(input, jsonEncoder.Value); err != nil { 1413 return out, metadata, &smithy.SerializationError{Err: err} 1414 } 1415 1416 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1417 return out, metadata, &smithy.SerializationError{Err: err} 1418 } 1419 1420 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1421 return out, metadata, &smithy.SerializationError{Err: err} 1422 } 1423 in.Request = request 1424 1425 return next.HandleSerialize(ctx, in) 1426} 1427 1428type awsAwsjson11_serializeOpPutAccountSettingDefault struct { 1429} 1430 1431func (*awsAwsjson11_serializeOpPutAccountSettingDefault) ID() string { 1432 return "OperationSerializer" 1433} 1434 1435func (m *awsAwsjson11_serializeOpPutAccountSettingDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1436 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1437) { 1438 request, ok := in.Request.(*smithyhttp.Request) 1439 if !ok { 1440 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1441 } 1442 1443 input, ok := in.Parameters.(*PutAccountSettingDefaultInput) 1444 _ = input 1445 if !ok { 1446 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1447 } 1448 1449 request.Request.URL.Path = "/" 1450 request.Request.Method = "POST" 1451 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1452 if err != nil { 1453 return out, metadata, &smithy.SerializationError{Err: err} 1454 } 1455 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1456 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.PutAccountSettingDefault") 1457 1458 jsonEncoder := smithyjson.NewEncoder() 1459 if err := awsAwsjson11_serializeOpDocumentPutAccountSettingDefaultInput(input, jsonEncoder.Value); err != nil { 1460 return out, metadata, &smithy.SerializationError{Err: err} 1461 } 1462 1463 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1464 return out, metadata, &smithy.SerializationError{Err: err} 1465 } 1466 1467 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1468 return out, metadata, &smithy.SerializationError{Err: err} 1469 } 1470 in.Request = request 1471 1472 return next.HandleSerialize(ctx, in) 1473} 1474 1475type awsAwsjson11_serializeOpPutAttributes struct { 1476} 1477 1478func (*awsAwsjson11_serializeOpPutAttributes) ID() string { 1479 return "OperationSerializer" 1480} 1481 1482func (m *awsAwsjson11_serializeOpPutAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1483 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1484) { 1485 request, ok := in.Request.(*smithyhttp.Request) 1486 if !ok { 1487 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1488 } 1489 1490 input, ok := in.Parameters.(*PutAttributesInput) 1491 _ = input 1492 if !ok { 1493 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1494 } 1495 1496 request.Request.URL.Path = "/" 1497 request.Request.Method = "POST" 1498 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1499 if err != nil { 1500 return out, metadata, &smithy.SerializationError{Err: err} 1501 } 1502 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1503 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.PutAttributes") 1504 1505 jsonEncoder := smithyjson.NewEncoder() 1506 if err := awsAwsjson11_serializeOpDocumentPutAttributesInput(input, jsonEncoder.Value); err != nil { 1507 return out, metadata, &smithy.SerializationError{Err: err} 1508 } 1509 1510 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1511 return out, metadata, &smithy.SerializationError{Err: err} 1512 } 1513 1514 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1515 return out, metadata, &smithy.SerializationError{Err: err} 1516 } 1517 in.Request = request 1518 1519 return next.HandleSerialize(ctx, in) 1520} 1521 1522type awsAwsjson11_serializeOpPutClusterCapacityProviders struct { 1523} 1524 1525func (*awsAwsjson11_serializeOpPutClusterCapacityProviders) ID() string { 1526 return "OperationSerializer" 1527} 1528 1529func (m *awsAwsjson11_serializeOpPutClusterCapacityProviders) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1530 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1531) { 1532 request, ok := in.Request.(*smithyhttp.Request) 1533 if !ok { 1534 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1535 } 1536 1537 input, ok := in.Parameters.(*PutClusterCapacityProvidersInput) 1538 _ = input 1539 if !ok { 1540 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1541 } 1542 1543 request.Request.URL.Path = "/" 1544 request.Request.Method = "POST" 1545 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1546 if err != nil { 1547 return out, metadata, &smithy.SerializationError{Err: err} 1548 } 1549 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1550 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.PutClusterCapacityProviders") 1551 1552 jsonEncoder := smithyjson.NewEncoder() 1553 if err := awsAwsjson11_serializeOpDocumentPutClusterCapacityProvidersInput(input, jsonEncoder.Value); err != nil { 1554 return out, metadata, &smithy.SerializationError{Err: err} 1555 } 1556 1557 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1558 return out, metadata, &smithy.SerializationError{Err: err} 1559 } 1560 1561 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1562 return out, metadata, &smithy.SerializationError{Err: err} 1563 } 1564 in.Request = request 1565 1566 return next.HandleSerialize(ctx, in) 1567} 1568 1569type awsAwsjson11_serializeOpRegisterContainerInstance struct { 1570} 1571 1572func (*awsAwsjson11_serializeOpRegisterContainerInstance) ID() string { 1573 return "OperationSerializer" 1574} 1575 1576func (m *awsAwsjson11_serializeOpRegisterContainerInstance) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1577 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1578) { 1579 request, ok := in.Request.(*smithyhttp.Request) 1580 if !ok { 1581 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1582 } 1583 1584 input, ok := in.Parameters.(*RegisterContainerInstanceInput) 1585 _ = input 1586 if !ok { 1587 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1588 } 1589 1590 request.Request.URL.Path = "/" 1591 request.Request.Method = "POST" 1592 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1593 if err != nil { 1594 return out, metadata, &smithy.SerializationError{Err: err} 1595 } 1596 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1597 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.RegisterContainerInstance") 1598 1599 jsonEncoder := smithyjson.NewEncoder() 1600 if err := awsAwsjson11_serializeOpDocumentRegisterContainerInstanceInput(input, jsonEncoder.Value); err != nil { 1601 return out, metadata, &smithy.SerializationError{Err: err} 1602 } 1603 1604 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1605 return out, metadata, &smithy.SerializationError{Err: err} 1606 } 1607 1608 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1609 return out, metadata, &smithy.SerializationError{Err: err} 1610 } 1611 in.Request = request 1612 1613 return next.HandleSerialize(ctx, in) 1614} 1615 1616type awsAwsjson11_serializeOpRegisterTaskDefinition struct { 1617} 1618 1619func (*awsAwsjson11_serializeOpRegisterTaskDefinition) ID() string { 1620 return "OperationSerializer" 1621} 1622 1623func (m *awsAwsjson11_serializeOpRegisterTaskDefinition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1624 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1625) { 1626 request, ok := in.Request.(*smithyhttp.Request) 1627 if !ok { 1628 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1629 } 1630 1631 input, ok := in.Parameters.(*RegisterTaskDefinitionInput) 1632 _ = input 1633 if !ok { 1634 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1635 } 1636 1637 request.Request.URL.Path = "/" 1638 request.Request.Method = "POST" 1639 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1640 if err != nil { 1641 return out, metadata, &smithy.SerializationError{Err: err} 1642 } 1643 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1644 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.RegisterTaskDefinition") 1645 1646 jsonEncoder := smithyjson.NewEncoder() 1647 if err := awsAwsjson11_serializeOpDocumentRegisterTaskDefinitionInput(input, jsonEncoder.Value); err != nil { 1648 return out, metadata, &smithy.SerializationError{Err: err} 1649 } 1650 1651 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1652 return out, metadata, &smithy.SerializationError{Err: err} 1653 } 1654 1655 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1656 return out, metadata, &smithy.SerializationError{Err: err} 1657 } 1658 in.Request = request 1659 1660 return next.HandleSerialize(ctx, in) 1661} 1662 1663type awsAwsjson11_serializeOpRunTask struct { 1664} 1665 1666func (*awsAwsjson11_serializeOpRunTask) ID() string { 1667 return "OperationSerializer" 1668} 1669 1670func (m *awsAwsjson11_serializeOpRunTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1671 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1672) { 1673 request, ok := in.Request.(*smithyhttp.Request) 1674 if !ok { 1675 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1676 } 1677 1678 input, ok := in.Parameters.(*RunTaskInput) 1679 _ = input 1680 if !ok { 1681 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1682 } 1683 1684 request.Request.URL.Path = "/" 1685 request.Request.Method = "POST" 1686 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1687 if err != nil { 1688 return out, metadata, &smithy.SerializationError{Err: err} 1689 } 1690 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1691 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.RunTask") 1692 1693 jsonEncoder := smithyjson.NewEncoder() 1694 if err := awsAwsjson11_serializeOpDocumentRunTaskInput(input, jsonEncoder.Value); err != nil { 1695 return out, metadata, &smithy.SerializationError{Err: err} 1696 } 1697 1698 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1699 return out, metadata, &smithy.SerializationError{Err: err} 1700 } 1701 1702 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1703 return out, metadata, &smithy.SerializationError{Err: err} 1704 } 1705 in.Request = request 1706 1707 return next.HandleSerialize(ctx, in) 1708} 1709 1710type awsAwsjson11_serializeOpStartTask struct { 1711} 1712 1713func (*awsAwsjson11_serializeOpStartTask) ID() string { 1714 return "OperationSerializer" 1715} 1716 1717func (m *awsAwsjson11_serializeOpStartTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1718 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1719) { 1720 request, ok := in.Request.(*smithyhttp.Request) 1721 if !ok { 1722 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1723 } 1724 1725 input, ok := in.Parameters.(*StartTaskInput) 1726 _ = input 1727 if !ok { 1728 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1729 } 1730 1731 request.Request.URL.Path = "/" 1732 request.Request.Method = "POST" 1733 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1734 if err != nil { 1735 return out, metadata, &smithy.SerializationError{Err: err} 1736 } 1737 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1738 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.StartTask") 1739 1740 jsonEncoder := smithyjson.NewEncoder() 1741 if err := awsAwsjson11_serializeOpDocumentStartTaskInput(input, jsonEncoder.Value); err != nil { 1742 return out, metadata, &smithy.SerializationError{Err: err} 1743 } 1744 1745 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1746 return out, metadata, &smithy.SerializationError{Err: err} 1747 } 1748 1749 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1750 return out, metadata, &smithy.SerializationError{Err: err} 1751 } 1752 in.Request = request 1753 1754 return next.HandleSerialize(ctx, in) 1755} 1756 1757type awsAwsjson11_serializeOpStopTask struct { 1758} 1759 1760func (*awsAwsjson11_serializeOpStopTask) ID() string { 1761 return "OperationSerializer" 1762} 1763 1764func (m *awsAwsjson11_serializeOpStopTask) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1765 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1766) { 1767 request, ok := in.Request.(*smithyhttp.Request) 1768 if !ok { 1769 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1770 } 1771 1772 input, ok := in.Parameters.(*StopTaskInput) 1773 _ = input 1774 if !ok { 1775 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1776 } 1777 1778 request.Request.URL.Path = "/" 1779 request.Request.Method = "POST" 1780 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1781 if err != nil { 1782 return out, metadata, &smithy.SerializationError{Err: err} 1783 } 1784 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1785 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.StopTask") 1786 1787 jsonEncoder := smithyjson.NewEncoder() 1788 if err := awsAwsjson11_serializeOpDocumentStopTaskInput(input, jsonEncoder.Value); err != nil { 1789 return out, metadata, &smithy.SerializationError{Err: err} 1790 } 1791 1792 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1793 return out, metadata, &smithy.SerializationError{Err: err} 1794 } 1795 1796 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1797 return out, metadata, &smithy.SerializationError{Err: err} 1798 } 1799 in.Request = request 1800 1801 return next.HandleSerialize(ctx, in) 1802} 1803 1804type awsAwsjson11_serializeOpSubmitAttachmentStateChanges struct { 1805} 1806 1807func (*awsAwsjson11_serializeOpSubmitAttachmentStateChanges) ID() string { 1808 return "OperationSerializer" 1809} 1810 1811func (m *awsAwsjson11_serializeOpSubmitAttachmentStateChanges) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1812 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1813) { 1814 request, ok := in.Request.(*smithyhttp.Request) 1815 if !ok { 1816 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1817 } 1818 1819 input, ok := in.Parameters.(*SubmitAttachmentStateChangesInput) 1820 _ = input 1821 if !ok { 1822 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1823 } 1824 1825 request.Request.URL.Path = "/" 1826 request.Request.Method = "POST" 1827 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1828 if err != nil { 1829 return out, metadata, &smithy.SerializationError{Err: err} 1830 } 1831 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1832 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.SubmitAttachmentStateChanges") 1833 1834 jsonEncoder := smithyjson.NewEncoder() 1835 if err := awsAwsjson11_serializeOpDocumentSubmitAttachmentStateChangesInput(input, jsonEncoder.Value); err != nil { 1836 return out, metadata, &smithy.SerializationError{Err: err} 1837 } 1838 1839 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1840 return out, metadata, &smithy.SerializationError{Err: err} 1841 } 1842 1843 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1844 return out, metadata, &smithy.SerializationError{Err: err} 1845 } 1846 in.Request = request 1847 1848 return next.HandleSerialize(ctx, in) 1849} 1850 1851type awsAwsjson11_serializeOpSubmitContainerStateChange struct { 1852} 1853 1854func (*awsAwsjson11_serializeOpSubmitContainerStateChange) ID() string { 1855 return "OperationSerializer" 1856} 1857 1858func (m *awsAwsjson11_serializeOpSubmitContainerStateChange) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1859 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1860) { 1861 request, ok := in.Request.(*smithyhttp.Request) 1862 if !ok { 1863 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1864 } 1865 1866 input, ok := in.Parameters.(*SubmitContainerStateChangeInput) 1867 _ = input 1868 if !ok { 1869 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1870 } 1871 1872 request.Request.URL.Path = "/" 1873 request.Request.Method = "POST" 1874 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1875 if err != nil { 1876 return out, metadata, &smithy.SerializationError{Err: err} 1877 } 1878 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1879 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.SubmitContainerStateChange") 1880 1881 jsonEncoder := smithyjson.NewEncoder() 1882 if err := awsAwsjson11_serializeOpDocumentSubmitContainerStateChangeInput(input, jsonEncoder.Value); err != nil { 1883 return out, metadata, &smithy.SerializationError{Err: err} 1884 } 1885 1886 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1887 return out, metadata, &smithy.SerializationError{Err: err} 1888 } 1889 1890 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1891 return out, metadata, &smithy.SerializationError{Err: err} 1892 } 1893 in.Request = request 1894 1895 return next.HandleSerialize(ctx, in) 1896} 1897 1898type awsAwsjson11_serializeOpSubmitTaskStateChange struct { 1899} 1900 1901func (*awsAwsjson11_serializeOpSubmitTaskStateChange) ID() string { 1902 return "OperationSerializer" 1903} 1904 1905func (m *awsAwsjson11_serializeOpSubmitTaskStateChange) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1906 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1907) { 1908 request, ok := in.Request.(*smithyhttp.Request) 1909 if !ok { 1910 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1911 } 1912 1913 input, ok := in.Parameters.(*SubmitTaskStateChangeInput) 1914 _ = input 1915 if !ok { 1916 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1917 } 1918 1919 request.Request.URL.Path = "/" 1920 request.Request.Method = "POST" 1921 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1922 if err != nil { 1923 return out, metadata, &smithy.SerializationError{Err: err} 1924 } 1925 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1926 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.SubmitTaskStateChange") 1927 1928 jsonEncoder := smithyjson.NewEncoder() 1929 if err := awsAwsjson11_serializeOpDocumentSubmitTaskStateChangeInput(input, jsonEncoder.Value); err != nil { 1930 return out, metadata, &smithy.SerializationError{Err: err} 1931 } 1932 1933 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1934 return out, metadata, &smithy.SerializationError{Err: err} 1935 } 1936 1937 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1938 return out, metadata, &smithy.SerializationError{Err: err} 1939 } 1940 in.Request = request 1941 1942 return next.HandleSerialize(ctx, in) 1943} 1944 1945type awsAwsjson11_serializeOpTagResource struct { 1946} 1947 1948func (*awsAwsjson11_serializeOpTagResource) ID() string { 1949 return "OperationSerializer" 1950} 1951 1952func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1953 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1954) { 1955 request, ok := in.Request.(*smithyhttp.Request) 1956 if !ok { 1957 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1958 } 1959 1960 input, ok := in.Parameters.(*TagResourceInput) 1961 _ = input 1962 if !ok { 1963 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1964 } 1965 1966 request.Request.URL.Path = "/" 1967 request.Request.Method = "POST" 1968 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1969 if err != nil { 1970 return out, metadata, &smithy.SerializationError{Err: err} 1971 } 1972 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 1973 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.TagResource") 1974 1975 jsonEncoder := smithyjson.NewEncoder() 1976 if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1977 return out, metadata, &smithy.SerializationError{Err: err} 1978 } 1979 1980 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1981 return out, metadata, &smithy.SerializationError{Err: err} 1982 } 1983 1984 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1985 return out, metadata, &smithy.SerializationError{Err: err} 1986 } 1987 in.Request = request 1988 1989 return next.HandleSerialize(ctx, in) 1990} 1991 1992type awsAwsjson11_serializeOpUntagResource struct { 1993} 1994 1995func (*awsAwsjson11_serializeOpUntagResource) ID() string { 1996 return "OperationSerializer" 1997} 1998 1999func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2000 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2001) { 2002 request, ok := in.Request.(*smithyhttp.Request) 2003 if !ok { 2004 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2005 } 2006 2007 input, ok := in.Parameters.(*UntagResourceInput) 2008 _ = input 2009 if !ok { 2010 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2011 } 2012 2013 request.Request.URL.Path = "/" 2014 request.Request.Method = "POST" 2015 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2016 if err != nil { 2017 return out, metadata, &smithy.SerializationError{Err: err} 2018 } 2019 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2020 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UntagResource") 2021 2022 jsonEncoder := smithyjson.NewEncoder() 2023 if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil { 2024 return out, metadata, &smithy.SerializationError{Err: err} 2025 } 2026 2027 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2028 return out, metadata, &smithy.SerializationError{Err: err} 2029 } 2030 2031 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2032 return out, metadata, &smithy.SerializationError{Err: err} 2033 } 2034 in.Request = request 2035 2036 return next.HandleSerialize(ctx, in) 2037} 2038 2039type awsAwsjson11_serializeOpUpdateCapacityProvider struct { 2040} 2041 2042func (*awsAwsjson11_serializeOpUpdateCapacityProvider) ID() string { 2043 return "OperationSerializer" 2044} 2045 2046func (m *awsAwsjson11_serializeOpUpdateCapacityProvider) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2047 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2048) { 2049 request, ok := in.Request.(*smithyhttp.Request) 2050 if !ok { 2051 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2052 } 2053 2054 input, ok := in.Parameters.(*UpdateCapacityProviderInput) 2055 _ = input 2056 if !ok { 2057 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2058 } 2059 2060 request.Request.URL.Path = "/" 2061 request.Request.Method = "POST" 2062 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2063 if err != nil { 2064 return out, metadata, &smithy.SerializationError{Err: err} 2065 } 2066 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2067 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider") 2068 2069 jsonEncoder := smithyjson.NewEncoder() 2070 if err := awsAwsjson11_serializeOpDocumentUpdateCapacityProviderInput(input, jsonEncoder.Value); err != nil { 2071 return out, metadata, &smithy.SerializationError{Err: err} 2072 } 2073 2074 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2075 return out, metadata, &smithy.SerializationError{Err: err} 2076 } 2077 2078 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2079 return out, metadata, &smithy.SerializationError{Err: err} 2080 } 2081 in.Request = request 2082 2083 return next.HandleSerialize(ctx, in) 2084} 2085 2086type awsAwsjson11_serializeOpUpdateClusterSettings struct { 2087} 2088 2089func (*awsAwsjson11_serializeOpUpdateClusterSettings) ID() string { 2090 return "OperationSerializer" 2091} 2092 2093func (m *awsAwsjson11_serializeOpUpdateClusterSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2094 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2095) { 2096 request, ok := in.Request.(*smithyhttp.Request) 2097 if !ok { 2098 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2099 } 2100 2101 input, ok := in.Parameters.(*UpdateClusterSettingsInput) 2102 _ = input 2103 if !ok { 2104 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2105 } 2106 2107 request.Request.URL.Path = "/" 2108 request.Request.Method = "POST" 2109 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2110 if err != nil { 2111 return out, metadata, &smithy.SerializationError{Err: err} 2112 } 2113 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2114 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateClusterSettings") 2115 2116 jsonEncoder := smithyjson.NewEncoder() 2117 if err := awsAwsjson11_serializeOpDocumentUpdateClusterSettingsInput(input, jsonEncoder.Value); err != nil { 2118 return out, metadata, &smithy.SerializationError{Err: err} 2119 } 2120 2121 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2122 return out, metadata, &smithy.SerializationError{Err: err} 2123 } 2124 2125 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2126 return out, metadata, &smithy.SerializationError{Err: err} 2127 } 2128 in.Request = request 2129 2130 return next.HandleSerialize(ctx, in) 2131} 2132 2133type awsAwsjson11_serializeOpUpdateContainerAgent struct { 2134} 2135 2136func (*awsAwsjson11_serializeOpUpdateContainerAgent) ID() string { 2137 return "OperationSerializer" 2138} 2139 2140func (m *awsAwsjson11_serializeOpUpdateContainerAgent) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2141 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2142) { 2143 request, ok := in.Request.(*smithyhttp.Request) 2144 if !ok { 2145 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2146 } 2147 2148 input, ok := in.Parameters.(*UpdateContainerAgentInput) 2149 _ = input 2150 if !ok { 2151 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2152 } 2153 2154 request.Request.URL.Path = "/" 2155 request.Request.Method = "POST" 2156 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2157 if err != nil { 2158 return out, metadata, &smithy.SerializationError{Err: err} 2159 } 2160 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2161 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateContainerAgent") 2162 2163 jsonEncoder := smithyjson.NewEncoder() 2164 if err := awsAwsjson11_serializeOpDocumentUpdateContainerAgentInput(input, jsonEncoder.Value); err != nil { 2165 return out, metadata, &smithy.SerializationError{Err: err} 2166 } 2167 2168 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2169 return out, metadata, &smithy.SerializationError{Err: err} 2170 } 2171 2172 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2173 return out, metadata, &smithy.SerializationError{Err: err} 2174 } 2175 in.Request = request 2176 2177 return next.HandleSerialize(ctx, in) 2178} 2179 2180type awsAwsjson11_serializeOpUpdateContainerInstancesState struct { 2181} 2182 2183func (*awsAwsjson11_serializeOpUpdateContainerInstancesState) ID() string { 2184 return "OperationSerializer" 2185} 2186 2187func (m *awsAwsjson11_serializeOpUpdateContainerInstancesState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2188 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2189) { 2190 request, ok := in.Request.(*smithyhttp.Request) 2191 if !ok { 2192 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2193 } 2194 2195 input, ok := in.Parameters.(*UpdateContainerInstancesStateInput) 2196 _ = input 2197 if !ok { 2198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2199 } 2200 2201 request.Request.URL.Path = "/" 2202 request.Request.Method = "POST" 2203 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2204 if err != nil { 2205 return out, metadata, &smithy.SerializationError{Err: err} 2206 } 2207 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2208 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState") 2209 2210 jsonEncoder := smithyjson.NewEncoder() 2211 if err := awsAwsjson11_serializeOpDocumentUpdateContainerInstancesStateInput(input, jsonEncoder.Value); err != nil { 2212 return out, metadata, &smithy.SerializationError{Err: err} 2213 } 2214 2215 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2216 return out, metadata, &smithy.SerializationError{Err: err} 2217 } 2218 2219 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2220 return out, metadata, &smithy.SerializationError{Err: err} 2221 } 2222 in.Request = request 2223 2224 return next.HandleSerialize(ctx, in) 2225} 2226 2227type awsAwsjson11_serializeOpUpdateService struct { 2228} 2229 2230func (*awsAwsjson11_serializeOpUpdateService) ID() string { 2231 return "OperationSerializer" 2232} 2233 2234func (m *awsAwsjson11_serializeOpUpdateService) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2235 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2236) { 2237 request, ok := in.Request.(*smithyhttp.Request) 2238 if !ok { 2239 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2240 } 2241 2242 input, ok := in.Parameters.(*UpdateServiceInput) 2243 _ = input 2244 if !ok { 2245 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2246 } 2247 2248 request.Request.URL.Path = "/" 2249 request.Request.Method = "POST" 2250 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2251 if err != nil { 2252 return out, metadata, &smithy.SerializationError{Err: err} 2253 } 2254 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2255 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateService") 2256 2257 jsonEncoder := smithyjson.NewEncoder() 2258 if err := awsAwsjson11_serializeOpDocumentUpdateServiceInput(input, jsonEncoder.Value); err != nil { 2259 return out, metadata, &smithy.SerializationError{Err: err} 2260 } 2261 2262 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2263 return out, metadata, &smithy.SerializationError{Err: err} 2264 } 2265 2266 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2267 return out, metadata, &smithy.SerializationError{Err: err} 2268 } 2269 in.Request = request 2270 2271 return next.HandleSerialize(ctx, in) 2272} 2273 2274type awsAwsjson11_serializeOpUpdateServicePrimaryTaskSet struct { 2275} 2276 2277func (*awsAwsjson11_serializeOpUpdateServicePrimaryTaskSet) ID() string { 2278 return "OperationSerializer" 2279} 2280 2281func (m *awsAwsjson11_serializeOpUpdateServicePrimaryTaskSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2282 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2283) { 2284 request, ok := in.Request.(*smithyhttp.Request) 2285 if !ok { 2286 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2287 } 2288 2289 input, ok := in.Parameters.(*UpdateServicePrimaryTaskSetInput) 2290 _ = input 2291 if !ok { 2292 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2293 } 2294 2295 request.Request.URL.Path = "/" 2296 request.Request.Method = "POST" 2297 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2298 if err != nil { 2299 return out, metadata, &smithy.SerializationError{Err: err} 2300 } 2301 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2302 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet") 2303 2304 jsonEncoder := smithyjson.NewEncoder() 2305 if err := awsAwsjson11_serializeOpDocumentUpdateServicePrimaryTaskSetInput(input, jsonEncoder.Value); err != nil { 2306 return out, metadata, &smithy.SerializationError{Err: err} 2307 } 2308 2309 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2310 return out, metadata, &smithy.SerializationError{Err: err} 2311 } 2312 2313 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2314 return out, metadata, &smithy.SerializationError{Err: err} 2315 } 2316 in.Request = request 2317 2318 return next.HandleSerialize(ctx, in) 2319} 2320 2321type awsAwsjson11_serializeOpUpdateTaskSet struct { 2322} 2323 2324func (*awsAwsjson11_serializeOpUpdateTaskSet) ID() string { 2325 return "OperationSerializer" 2326} 2327 2328func (m *awsAwsjson11_serializeOpUpdateTaskSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2329 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2330) { 2331 request, ok := in.Request.(*smithyhttp.Request) 2332 if !ok { 2333 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2334 } 2335 2336 input, ok := in.Parameters.(*UpdateTaskSetInput) 2337 _ = input 2338 if !ok { 2339 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2340 } 2341 2342 request.Request.URL.Path = "/" 2343 request.Request.Method = "POST" 2344 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2345 if err != nil { 2346 return out, metadata, &smithy.SerializationError{Err: err} 2347 } 2348 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2349 httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonEC2ContainerServiceV20141113.UpdateTaskSet") 2350 2351 jsonEncoder := smithyjson.NewEncoder() 2352 if err := awsAwsjson11_serializeOpDocumentUpdateTaskSetInput(input, jsonEncoder.Value); err != nil { 2353 return out, metadata, &smithy.SerializationError{Err: err} 2354 } 2355 2356 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2357 return out, metadata, &smithy.SerializationError{Err: err} 2358 } 2359 2360 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2361 return out, metadata, &smithy.SerializationError{Err: err} 2362 } 2363 in.Request = request 2364 2365 return next.HandleSerialize(ctx, in) 2366} 2367func awsAwsjson11_serializeDocumentAttachmentStateChange(v *types.AttachmentStateChange, value smithyjson.Value) error { 2368 object := value.Object() 2369 defer object.Close() 2370 2371 if v.AttachmentArn != nil { 2372 ok := object.Key("attachmentArn") 2373 ok.String(*v.AttachmentArn) 2374 } 2375 2376 if v.Status != nil { 2377 ok := object.Key("status") 2378 ok.String(*v.Status) 2379 } 2380 2381 return nil 2382} 2383 2384func awsAwsjson11_serializeDocumentAttachmentStateChanges(v []types.AttachmentStateChange, value smithyjson.Value) error { 2385 array := value.Array() 2386 defer array.Close() 2387 2388 for i := range v { 2389 av := array.Value() 2390 if err := awsAwsjson11_serializeDocumentAttachmentStateChange(&v[i], av); err != nil { 2391 return err 2392 } 2393 } 2394 return nil 2395} 2396 2397func awsAwsjson11_serializeDocumentAttribute(v *types.Attribute, value smithyjson.Value) error { 2398 object := value.Object() 2399 defer object.Close() 2400 2401 if v.Name != nil { 2402 ok := object.Key("name") 2403 ok.String(*v.Name) 2404 } 2405 2406 if v.TargetId != nil { 2407 ok := object.Key("targetId") 2408 ok.String(*v.TargetId) 2409 } 2410 2411 if len(v.TargetType) > 0 { 2412 ok := object.Key("targetType") 2413 ok.String(string(v.TargetType)) 2414 } 2415 2416 if v.Value != nil { 2417 ok := object.Key("value") 2418 ok.String(*v.Value) 2419 } 2420 2421 return nil 2422} 2423 2424func awsAwsjson11_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error { 2425 array := value.Array() 2426 defer array.Close() 2427 2428 for i := range v { 2429 av := array.Value() 2430 if err := awsAwsjson11_serializeDocumentAttribute(&v[i], av); err != nil { 2431 return err 2432 } 2433 } 2434 return nil 2435} 2436 2437func awsAwsjson11_serializeDocumentAutoScalingGroupProvider(v *types.AutoScalingGroupProvider, value smithyjson.Value) error { 2438 object := value.Object() 2439 defer object.Close() 2440 2441 if v.AutoScalingGroupArn != nil { 2442 ok := object.Key("autoScalingGroupArn") 2443 ok.String(*v.AutoScalingGroupArn) 2444 } 2445 2446 if v.ManagedScaling != nil { 2447 ok := object.Key("managedScaling") 2448 if err := awsAwsjson11_serializeDocumentManagedScaling(v.ManagedScaling, ok); err != nil { 2449 return err 2450 } 2451 } 2452 2453 if len(v.ManagedTerminationProtection) > 0 { 2454 ok := object.Key("managedTerminationProtection") 2455 ok.String(string(v.ManagedTerminationProtection)) 2456 } 2457 2458 return nil 2459} 2460 2461func awsAwsjson11_serializeDocumentAutoScalingGroupProviderUpdate(v *types.AutoScalingGroupProviderUpdate, value smithyjson.Value) error { 2462 object := value.Object() 2463 defer object.Close() 2464 2465 if v.ManagedScaling != nil { 2466 ok := object.Key("managedScaling") 2467 if err := awsAwsjson11_serializeDocumentManagedScaling(v.ManagedScaling, ok); err != nil { 2468 return err 2469 } 2470 } 2471 2472 if len(v.ManagedTerminationProtection) > 0 { 2473 ok := object.Key("managedTerminationProtection") 2474 ok.String(string(v.ManagedTerminationProtection)) 2475 } 2476 2477 return nil 2478} 2479 2480func awsAwsjson11_serializeDocumentAwsVpcConfiguration(v *types.AwsVpcConfiguration, value smithyjson.Value) error { 2481 object := value.Object() 2482 defer object.Close() 2483 2484 if len(v.AssignPublicIp) > 0 { 2485 ok := object.Key("assignPublicIp") 2486 ok.String(string(v.AssignPublicIp)) 2487 } 2488 2489 if v.SecurityGroups != nil { 2490 ok := object.Key("securityGroups") 2491 if err := awsAwsjson11_serializeDocumentStringList(v.SecurityGroups, ok); err != nil { 2492 return err 2493 } 2494 } 2495 2496 if v.Subnets != nil { 2497 ok := object.Key("subnets") 2498 if err := awsAwsjson11_serializeDocumentStringList(v.Subnets, ok); err != nil { 2499 return err 2500 } 2501 } 2502 2503 return nil 2504} 2505 2506func awsAwsjson11_serializeDocumentCapacityProviderFieldList(v []types.CapacityProviderField, value smithyjson.Value) error { 2507 array := value.Array() 2508 defer array.Close() 2509 2510 for i := range v { 2511 av := array.Value() 2512 av.String(string(v[i])) 2513 } 2514 return nil 2515} 2516 2517func awsAwsjson11_serializeDocumentCapacityProviderStrategy(v []types.CapacityProviderStrategyItem, value smithyjson.Value) error { 2518 array := value.Array() 2519 defer array.Close() 2520 2521 for i := range v { 2522 av := array.Value() 2523 if err := awsAwsjson11_serializeDocumentCapacityProviderStrategyItem(&v[i], av); err != nil { 2524 return err 2525 } 2526 } 2527 return nil 2528} 2529 2530func awsAwsjson11_serializeDocumentCapacityProviderStrategyItem(v *types.CapacityProviderStrategyItem, value smithyjson.Value) error { 2531 object := value.Object() 2532 defer object.Close() 2533 2534 if v.Base != 0 { 2535 ok := object.Key("base") 2536 ok.Integer(v.Base) 2537 } 2538 2539 if v.CapacityProvider != nil { 2540 ok := object.Key("capacityProvider") 2541 ok.String(*v.CapacityProvider) 2542 } 2543 2544 if v.Weight != 0 { 2545 ok := object.Key("weight") 2546 ok.Integer(v.Weight) 2547 } 2548 2549 return nil 2550} 2551 2552func awsAwsjson11_serializeDocumentClusterFieldList(v []types.ClusterField, value smithyjson.Value) error { 2553 array := value.Array() 2554 defer array.Close() 2555 2556 for i := range v { 2557 av := array.Value() 2558 av.String(string(v[i])) 2559 } 2560 return nil 2561} 2562 2563func awsAwsjson11_serializeDocumentClusterSetting(v *types.ClusterSetting, value smithyjson.Value) error { 2564 object := value.Object() 2565 defer object.Close() 2566 2567 if len(v.Name) > 0 { 2568 ok := object.Key("name") 2569 ok.String(string(v.Name)) 2570 } 2571 2572 if v.Value != nil { 2573 ok := object.Key("value") 2574 ok.String(*v.Value) 2575 } 2576 2577 return nil 2578} 2579 2580func awsAwsjson11_serializeDocumentClusterSettings(v []types.ClusterSetting, value smithyjson.Value) error { 2581 array := value.Array() 2582 defer array.Close() 2583 2584 for i := range v { 2585 av := array.Value() 2586 if err := awsAwsjson11_serializeDocumentClusterSetting(&v[i], av); err != nil { 2587 return err 2588 } 2589 } 2590 return nil 2591} 2592 2593func awsAwsjson11_serializeDocumentCompatibilityList(v []types.Compatibility, value smithyjson.Value) error { 2594 array := value.Array() 2595 defer array.Close() 2596 2597 for i := range v { 2598 av := array.Value() 2599 av.String(string(v[i])) 2600 } 2601 return nil 2602} 2603 2604func awsAwsjson11_serializeDocumentContainerDefinition(v *types.ContainerDefinition, value smithyjson.Value) error { 2605 object := value.Object() 2606 defer object.Close() 2607 2608 if v.Command != nil { 2609 ok := object.Key("command") 2610 if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil { 2611 return err 2612 } 2613 } 2614 2615 if v.Cpu != 0 { 2616 ok := object.Key("cpu") 2617 ok.Integer(v.Cpu) 2618 } 2619 2620 if v.DependsOn != nil { 2621 ok := object.Key("dependsOn") 2622 if err := awsAwsjson11_serializeDocumentContainerDependencies(v.DependsOn, ok); err != nil { 2623 return err 2624 } 2625 } 2626 2627 if v.DisableNetworking != nil { 2628 ok := object.Key("disableNetworking") 2629 ok.Boolean(*v.DisableNetworking) 2630 } 2631 2632 if v.DnsSearchDomains != nil { 2633 ok := object.Key("dnsSearchDomains") 2634 if err := awsAwsjson11_serializeDocumentStringList(v.DnsSearchDomains, ok); err != nil { 2635 return err 2636 } 2637 } 2638 2639 if v.DnsServers != nil { 2640 ok := object.Key("dnsServers") 2641 if err := awsAwsjson11_serializeDocumentStringList(v.DnsServers, ok); err != nil { 2642 return err 2643 } 2644 } 2645 2646 if v.DockerLabels != nil { 2647 ok := object.Key("dockerLabels") 2648 if err := awsAwsjson11_serializeDocumentDockerLabelsMap(v.DockerLabels, ok); err != nil { 2649 return err 2650 } 2651 } 2652 2653 if v.DockerSecurityOptions != nil { 2654 ok := object.Key("dockerSecurityOptions") 2655 if err := awsAwsjson11_serializeDocumentStringList(v.DockerSecurityOptions, ok); err != nil { 2656 return err 2657 } 2658 } 2659 2660 if v.EntryPoint != nil { 2661 ok := object.Key("entryPoint") 2662 if err := awsAwsjson11_serializeDocumentStringList(v.EntryPoint, ok); err != nil { 2663 return err 2664 } 2665 } 2666 2667 if v.Environment != nil { 2668 ok := object.Key("environment") 2669 if err := awsAwsjson11_serializeDocumentEnvironmentVariables(v.Environment, ok); err != nil { 2670 return err 2671 } 2672 } 2673 2674 if v.EnvironmentFiles != nil { 2675 ok := object.Key("environmentFiles") 2676 if err := awsAwsjson11_serializeDocumentEnvironmentFiles(v.EnvironmentFiles, ok); err != nil { 2677 return err 2678 } 2679 } 2680 2681 if v.Essential != nil { 2682 ok := object.Key("essential") 2683 ok.Boolean(*v.Essential) 2684 } 2685 2686 if v.ExtraHosts != nil { 2687 ok := object.Key("extraHosts") 2688 if err := awsAwsjson11_serializeDocumentHostEntryList(v.ExtraHosts, ok); err != nil { 2689 return err 2690 } 2691 } 2692 2693 if v.FirelensConfiguration != nil { 2694 ok := object.Key("firelensConfiguration") 2695 if err := awsAwsjson11_serializeDocumentFirelensConfiguration(v.FirelensConfiguration, ok); err != nil { 2696 return err 2697 } 2698 } 2699 2700 if v.HealthCheck != nil { 2701 ok := object.Key("healthCheck") 2702 if err := awsAwsjson11_serializeDocumentHealthCheck(v.HealthCheck, ok); err != nil { 2703 return err 2704 } 2705 } 2706 2707 if v.Hostname != nil { 2708 ok := object.Key("hostname") 2709 ok.String(*v.Hostname) 2710 } 2711 2712 if v.Image != nil { 2713 ok := object.Key("image") 2714 ok.String(*v.Image) 2715 } 2716 2717 if v.Interactive != nil { 2718 ok := object.Key("interactive") 2719 ok.Boolean(*v.Interactive) 2720 } 2721 2722 if v.Links != nil { 2723 ok := object.Key("links") 2724 if err := awsAwsjson11_serializeDocumentStringList(v.Links, ok); err != nil { 2725 return err 2726 } 2727 } 2728 2729 if v.LinuxParameters != nil { 2730 ok := object.Key("linuxParameters") 2731 if err := awsAwsjson11_serializeDocumentLinuxParameters(v.LinuxParameters, ok); err != nil { 2732 return err 2733 } 2734 } 2735 2736 if v.LogConfiguration != nil { 2737 ok := object.Key("logConfiguration") 2738 if err := awsAwsjson11_serializeDocumentLogConfiguration(v.LogConfiguration, ok); err != nil { 2739 return err 2740 } 2741 } 2742 2743 if v.Memory != nil { 2744 ok := object.Key("memory") 2745 ok.Integer(*v.Memory) 2746 } 2747 2748 if v.MemoryReservation != nil { 2749 ok := object.Key("memoryReservation") 2750 ok.Integer(*v.MemoryReservation) 2751 } 2752 2753 if v.MountPoints != nil { 2754 ok := object.Key("mountPoints") 2755 if err := awsAwsjson11_serializeDocumentMountPointList(v.MountPoints, ok); err != nil { 2756 return err 2757 } 2758 } 2759 2760 if v.Name != nil { 2761 ok := object.Key("name") 2762 ok.String(*v.Name) 2763 } 2764 2765 if v.PortMappings != nil { 2766 ok := object.Key("portMappings") 2767 if err := awsAwsjson11_serializeDocumentPortMappingList(v.PortMappings, ok); err != nil { 2768 return err 2769 } 2770 } 2771 2772 if v.Privileged != nil { 2773 ok := object.Key("privileged") 2774 ok.Boolean(*v.Privileged) 2775 } 2776 2777 if v.PseudoTerminal != nil { 2778 ok := object.Key("pseudoTerminal") 2779 ok.Boolean(*v.PseudoTerminal) 2780 } 2781 2782 if v.ReadonlyRootFilesystem != nil { 2783 ok := object.Key("readonlyRootFilesystem") 2784 ok.Boolean(*v.ReadonlyRootFilesystem) 2785 } 2786 2787 if v.RepositoryCredentials != nil { 2788 ok := object.Key("repositoryCredentials") 2789 if err := awsAwsjson11_serializeDocumentRepositoryCredentials(v.RepositoryCredentials, ok); err != nil { 2790 return err 2791 } 2792 } 2793 2794 if v.ResourceRequirements != nil { 2795 ok := object.Key("resourceRequirements") 2796 if err := awsAwsjson11_serializeDocumentResourceRequirements(v.ResourceRequirements, ok); err != nil { 2797 return err 2798 } 2799 } 2800 2801 if v.Secrets != nil { 2802 ok := object.Key("secrets") 2803 if err := awsAwsjson11_serializeDocumentSecretList(v.Secrets, ok); err != nil { 2804 return err 2805 } 2806 } 2807 2808 if v.StartTimeout != nil { 2809 ok := object.Key("startTimeout") 2810 ok.Integer(*v.StartTimeout) 2811 } 2812 2813 if v.StopTimeout != nil { 2814 ok := object.Key("stopTimeout") 2815 ok.Integer(*v.StopTimeout) 2816 } 2817 2818 if v.SystemControls != nil { 2819 ok := object.Key("systemControls") 2820 if err := awsAwsjson11_serializeDocumentSystemControls(v.SystemControls, ok); err != nil { 2821 return err 2822 } 2823 } 2824 2825 if v.Ulimits != nil { 2826 ok := object.Key("ulimits") 2827 if err := awsAwsjson11_serializeDocumentUlimitList(v.Ulimits, ok); err != nil { 2828 return err 2829 } 2830 } 2831 2832 if v.User != nil { 2833 ok := object.Key("user") 2834 ok.String(*v.User) 2835 } 2836 2837 if v.VolumesFrom != nil { 2838 ok := object.Key("volumesFrom") 2839 if err := awsAwsjson11_serializeDocumentVolumeFromList(v.VolumesFrom, ok); err != nil { 2840 return err 2841 } 2842 } 2843 2844 if v.WorkingDirectory != nil { 2845 ok := object.Key("workingDirectory") 2846 ok.String(*v.WorkingDirectory) 2847 } 2848 2849 return nil 2850} 2851 2852func awsAwsjson11_serializeDocumentContainerDefinitions(v []types.ContainerDefinition, value smithyjson.Value) error { 2853 array := value.Array() 2854 defer array.Close() 2855 2856 for i := range v { 2857 av := array.Value() 2858 if err := awsAwsjson11_serializeDocumentContainerDefinition(&v[i], av); err != nil { 2859 return err 2860 } 2861 } 2862 return nil 2863} 2864 2865func awsAwsjson11_serializeDocumentContainerDependencies(v []types.ContainerDependency, value smithyjson.Value) error { 2866 array := value.Array() 2867 defer array.Close() 2868 2869 for i := range v { 2870 av := array.Value() 2871 if err := awsAwsjson11_serializeDocumentContainerDependency(&v[i], av); err != nil { 2872 return err 2873 } 2874 } 2875 return nil 2876} 2877 2878func awsAwsjson11_serializeDocumentContainerDependency(v *types.ContainerDependency, value smithyjson.Value) error { 2879 object := value.Object() 2880 defer object.Close() 2881 2882 if len(v.Condition) > 0 { 2883 ok := object.Key("condition") 2884 ok.String(string(v.Condition)) 2885 } 2886 2887 if v.ContainerName != nil { 2888 ok := object.Key("containerName") 2889 ok.String(*v.ContainerName) 2890 } 2891 2892 return nil 2893} 2894 2895func awsAwsjson11_serializeDocumentContainerInstanceFieldList(v []types.ContainerInstanceField, value smithyjson.Value) error { 2896 array := value.Array() 2897 defer array.Close() 2898 2899 for i := range v { 2900 av := array.Value() 2901 av.String(string(v[i])) 2902 } 2903 return nil 2904} 2905 2906func awsAwsjson11_serializeDocumentContainerOverride(v *types.ContainerOverride, value smithyjson.Value) error { 2907 object := value.Object() 2908 defer object.Close() 2909 2910 if v.Command != nil { 2911 ok := object.Key("command") 2912 if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil { 2913 return err 2914 } 2915 } 2916 2917 if v.Cpu != nil { 2918 ok := object.Key("cpu") 2919 ok.Integer(*v.Cpu) 2920 } 2921 2922 if v.Environment != nil { 2923 ok := object.Key("environment") 2924 if err := awsAwsjson11_serializeDocumentEnvironmentVariables(v.Environment, ok); err != nil { 2925 return err 2926 } 2927 } 2928 2929 if v.EnvironmentFiles != nil { 2930 ok := object.Key("environmentFiles") 2931 if err := awsAwsjson11_serializeDocumentEnvironmentFiles(v.EnvironmentFiles, ok); err != nil { 2932 return err 2933 } 2934 } 2935 2936 if v.Memory != nil { 2937 ok := object.Key("memory") 2938 ok.Integer(*v.Memory) 2939 } 2940 2941 if v.MemoryReservation != nil { 2942 ok := object.Key("memoryReservation") 2943 ok.Integer(*v.MemoryReservation) 2944 } 2945 2946 if v.Name != nil { 2947 ok := object.Key("name") 2948 ok.String(*v.Name) 2949 } 2950 2951 if v.ResourceRequirements != nil { 2952 ok := object.Key("resourceRequirements") 2953 if err := awsAwsjson11_serializeDocumentResourceRequirements(v.ResourceRequirements, ok); err != nil { 2954 return err 2955 } 2956 } 2957 2958 return nil 2959} 2960 2961func awsAwsjson11_serializeDocumentContainerOverrides(v []types.ContainerOverride, value smithyjson.Value) error { 2962 array := value.Array() 2963 defer array.Close() 2964 2965 for i := range v { 2966 av := array.Value() 2967 if err := awsAwsjson11_serializeDocumentContainerOverride(&v[i], av); err != nil { 2968 return err 2969 } 2970 } 2971 return nil 2972} 2973 2974func awsAwsjson11_serializeDocumentContainerStateChange(v *types.ContainerStateChange, value smithyjson.Value) error { 2975 object := value.Object() 2976 defer object.Close() 2977 2978 if v.ContainerName != nil { 2979 ok := object.Key("containerName") 2980 ok.String(*v.ContainerName) 2981 } 2982 2983 if v.ExitCode != nil { 2984 ok := object.Key("exitCode") 2985 ok.Integer(*v.ExitCode) 2986 } 2987 2988 if v.ImageDigest != nil { 2989 ok := object.Key("imageDigest") 2990 ok.String(*v.ImageDigest) 2991 } 2992 2993 if v.NetworkBindings != nil { 2994 ok := object.Key("networkBindings") 2995 if err := awsAwsjson11_serializeDocumentNetworkBindings(v.NetworkBindings, ok); err != nil { 2996 return err 2997 } 2998 } 2999 3000 if v.Reason != nil { 3001 ok := object.Key("reason") 3002 ok.String(*v.Reason) 3003 } 3004 3005 if v.RuntimeId != nil { 3006 ok := object.Key("runtimeId") 3007 ok.String(*v.RuntimeId) 3008 } 3009 3010 if v.Status != nil { 3011 ok := object.Key("status") 3012 ok.String(*v.Status) 3013 } 3014 3015 return nil 3016} 3017 3018func awsAwsjson11_serializeDocumentContainerStateChanges(v []types.ContainerStateChange, value smithyjson.Value) error { 3019 array := value.Array() 3020 defer array.Close() 3021 3022 for i := range v { 3023 av := array.Value() 3024 if err := awsAwsjson11_serializeDocumentContainerStateChange(&v[i], av); err != nil { 3025 return err 3026 } 3027 } 3028 return nil 3029} 3030 3031func awsAwsjson11_serializeDocumentDeploymentCircuitBreaker(v *types.DeploymentCircuitBreaker, value smithyjson.Value) error { 3032 object := value.Object() 3033 defer object.Close() 3034 3035 if v.Enable { 3036 ok := object.Key("enable") 3037 ok.Boolean(v.Enable) 3038 } 3039 3040 if v.Rollback { 3041 ok := object.Key("rollback") 3042 ok.Boolean(v.Rollback) 3043 } 3044 3045 return nil 3046} 3047 3048func awsAwsjson11_serializeDocumentDeploymentConfiguration(v *types.DeploymentConfiguration, value smithyjson.Value) error { 3049 object := value.Object() 3050 defer object.Close() 3051 3052 if v.DeploymentCircuitBreaker != nil { 3053 ok := object.Key("deploymentCircuitBreaker") 3054 if err := awsAwsjson11_serializeDocumentDeploymentCircuitBreaker(v.DeploymentCircuitBreaker, ok); err != nil { 3055 return err 3056 } 3057 } 3058 3059 if v.MaximumPercent != nil { 3060 ok := object.Key("maximumPercent") 3061 ok.Integer(*v.MaximumPercent) 3062 } 3063 3064 if v.MinimumHealthyPercent != nil { 3065 ok := object.Key("minimumHealthyPercent") 3066 ok.Integer(*v.MinimumHealthyPercent) 3067 } 3068 3069 return nil 3070} 3071 3072func awsAwsjson11_serializeDocumentDeploymentController(v *types.DeploymentController, value smithyjson.Value) error { 3073 object := value.Object() 3074 defer object.Close() 3075 3076 if len(v.Type) > 0 { 3077 ok := object.Key("type") 3078 ok.String(string(v.Type)) 3079 } 3080 3081 return nil 3082} 3083 3084func awsAwsjson11_serializeDocumentDevice(v *types.Device, value smithyjson.Value) error { 3085 object := value.Object() 3086 defer object.Close() 3087 3088 if v.ContainerPath != nil { 3089 ok := object.Key("containerPath") 3090 ok.String(*v.ContainerPath) 3091 } 3092 3093 if v.HostPath != nil { 3094 ok := object.Key("hostPath") 3095 ok.String(*v.HostPath) 3096 } 3097 3098 if v.Permissions != nil { 3099 ok := object.Key("permissions") 3100 if err := awsAwsjson11_serializeDocumentDeviceCgroupPermissions(v.Permissions, ok); err != nil { 3101 return err 3102 } 3103 } 3104 3105 return nil 3106} 3107 3108func awsAwsjson11_serializeDocumentDeviceCgroupPermissions(v []types.DeviceCgroupPermission, value smithyjson.Value) error { 3109 array := value.Array() 3110 defer array.Close() 3111 3112 for i := range v { 3113 av := array.Value() 3114 av.String(string(v[i])) 3115 } 3116 return nil 3117} 3118 3119func awsAwsjson11_serializeDocumentDevicesList(v []types.Device, value smithyjson.Value) error { 3120 array := value.Array() 3121 defer array.Close() 3122 3123 for i := range v { 3124 av := array.Value() 3125 if err := awsAwsjson11_serializeDocumentDevice(&v[i], av); err != nil { 3126 return err 3127 } 3128 } 3129 return nil 3130} 3131 3132func awsAwsjson11_serializeDocumentDockerLabelsMap(v map[string]string, value smithyjson.Value) error { 3133 object := value.Object() 3134 defer object.Close() 3135 3136 for key := range v { 3137 om := object.Key(key) 3138 om.String(v[key]) 3139 } 3140 return nil 3141} 3142 3143func awsAwsjson11_serializeDocumentDockerVolumeConfiguration(v *types.DockerVolumeConfiguration, value smithyjson.Value) error { 3144 object := value.Object() 3145 defer object.Close() 3146 3147 if v.Autoprovision != nil { 3148 ok := object.Key("autoprovision") 3149 ok.Boolean(*v.Autoprovision) 3150 } 3151 3152 if v.Driver != nil { 3153 ok := object.Key("driver") 3154 ok.String(*v.Driver) 3155 } 3156 3157 if v.DriverOpts != nil { 3158 ok := object.Key("driverOpts") 3159 if err := awsAwsjson11_serializeDocumentStringMap(v.DriverOpts, ok); err != nil { 3160 return err 3161 } 3162 } 3163 3164 if v.Labels != nil { 3165 ok := object.Key("labels") 3166 if err := awsAwsjson11_serializeDocumentStringMap(v.Labels, ok); err != nil { 3167 return err 3168 } 3169 } 3170 3171 if len(v.Scope) > 0 { 3172 ok := object.Key("scope") 3173 ok.String(string(v.Scope)) 3174 } 3175 3176 return nil 3177} 3178 3179func awsAwsjson11_serializeDocumentEFSAuthorizationConfig(v *types.EFSAuthorizationConfig, value smithyjson.Value) error { 3180 object := value.Object() 3181 defer object.Close() 3182 3183 if v.AccessPointId != nil { 3184 ok := object.Key("accessPointId") 3185 ok.String(*v.AccessPointId) 3186 } 3187 3188 if len(v.Iam) > 0 { 3189 ok := object.Key("iam") 3190 ok.String(string(v.Iam)) 3191 } 3192 3193 return nil 3194} 3195 3196func awsAwsjson11_serializeDocumentEFSVolumeConfiguration(v *types.EFSVolumeConfiguration, value smithyjson.Value) error { 3197 object := value.Object() 3198 defer object.Close() 3199 3200 if v.AuthorizationConfig != nil { 3201 ok := object.Key("authorizationConfig") 3202 if err := awsAwsjson11_serializeDocumentEFSAuthorizationConfig(v.AuthorizationConfig, ok); err != nil { 3203 return err 3204 } 3205 } 3206 3207 if v.FileSystemId != nil { 3208 ok := object.Key("fileSystemId") 3209 ok.String(*v.FileSystemId) 3210 } 3211 3212 if v.RootDirectory != nil { 3213 ok := object.Key("rootDirectory") 3214 ok.String(*v.RootDirectory) 3215 } 3216 3217 if len(v.TransitEncryption) > 0 { 3218 ok := object.Key("transitEncryption") 3219 ok.String(string(v.TransitEncryption)) 3220 } 3221 3222 if v.TransitEncryptionPort != nil { 3223 ok := object.Key("transitEncryptionPort") 3224 ok.Integer(*v.TransitEncryptionPort) 3225 } 3226 3227 return nil 3228} 3229 3230func awsAwsjson11_serializeDocumentEnvironmentFile(v *types.EnvironmentFile, value smithyjson.Value) error { 3231 object := value.Object() 3232 defer object.Close() 3233 3234 if len(v.Type) > 0 { 3235 ok := object.Key("type") 3236 ok.String(string(v.Type)) 3237 } 3238 3239 if v.Value != nil { 3240 ok := object.Key("value") 3241 ok.String(*v.Value) 3242 } 3243 3244 return nil 3245} 3246 3247func awsAwsjson11_serializeDocumentEnvironmentFiles(v []types.EnvironmentFile, value smithyjson.Value) error { 3248 array := value.Array() 3249 defer array.Close() 3250 3251 for i := range v { 3252 av := array.Value() 3253 if err := awsAwsjson11_serializeDocumentEnvironmentFile(&v[i], av); err != nil { 3254 return err 3255 } 3256 } 3257 return nil 3258} 3259 3260func awsAwsjson11_serializeDocumentEnvironmentVariables(v []types.KeyValuePair, value smithyjson.Value) error { 3261 array := value.Array() 3262 defer array.Close() 3263 3264 for i := range v { 3265 av := array.Value() 3266 if err := awsAwsjson11_serializeDocumentKeyValuePair(&v[i], av); err != nil { 3267 return err 3268 } 3269 } 3270 return nil 3271} 3272 3273func awsAwsjson11_serializeDocumentFirelensConfiguration(v *types.FirelensConfiguration, value smithyjson.Value) error { 3274 object := value.Object() 3275 defer object.Close() 3276 3277 if v.Options != nil { 3278 ok := object.Key("options") 3279 if err := awsAwsjson11_serializeDocumentFirelensConfigurationOptionsMap(v.Options, ok); err != nil { 3280 return err 3281 } 3282 } 3283 3284 if len(v.Type) > 0 { 3285 ok := object.Key("type") 3286 ok.String(string(v.Type)) 3287 } 3288 3289 return nil 3290} 3291 3292func awsAwsjson11_serializeDocumentFirelensConfigurationOptionsMap(v map[string]string, value smithyjson.Value) error { 3293 object := value.Object() 3294 defer object.Close() 3295 3296 for key := range v { 3297 om := object.Key(key) 3298 om.String(v[key]) 3299 } 3300 return nil 3301} 3302 3303func awsAwsjson11_serializeDocumentFSxWindowsFileServerAuthorizationConfig(v *types.FSxWindowsFileServerAuthorizationConfig, value smithyjson.Value) error { 3304 object := value.Object() 3305 defer object.Close() 3306 3307 if v.CredentialsParameter != nil { 3308 ok := object.Key("credentialsParameter") 3309 ok.String(*v.CredentialsParameter) 3310 } 3311 3312 if v.Domain != nil { 3313 ok := object.Key("domain") 3314 ok.String(*v.Domain) 3315 } 3316 3317 return nil 3318} 3319 3320func awsAwsjson11_serializeDocumentFSxWindowsFileServerVolumeConfiguration(v *types.FSxWindowsFileServerVolumeConfiguration, value smithyjson.Value) error { 3321 object := value.Object() 3322 defer object.Close() 3323 3324 if v.AuthorizationConfig != nil { 3325 ok := object.Key("authorizationConfig") 3326 if err := awsAwsjson11_serializeDocumentFSxWindowsFileServerAuthorizationConfig(v.AuthorizationConfig, ok); err != nil { 3327 return err 3328 } 3329 } 3330 3331 if v.FileSystemId != nil { 3332 ok := object.Key("fileSystemId") 3333 ok.String(*v.FileSystemId) 3334 } 3335 3336 if v.RootDirectory != nil { 3337 ok := object.Key("rootDirectory") 3338 ok.String(*v.RootDirectory) 3339 } 3340 3341 return nil 3342} 3343 3344func awsAwsjson11_serializeDocumentHealthCheck(v *types.HealthCheck, value smithyjson.Value) error { 3345 object := value.Object() 3346 defer object.Close() 3347 3348 if v.Command != nil { 3349 ok := object.Key("command") 3350 if err := awsAwsjson11_serializeDocumentStringList(v.Command, ok); err != nil { 3351 return err 3352 } 3353 } 3354 3355 if v.Interval != nil { 3356 ok := object.Key("interval") 3357 ok.Integer(*v.Interval) 3358 } 3359 3360 if v.Retries != nil { 3361 ok := object.Key("retries") 3362 ok.Integer(*v.Retries) 3363 } 3364 3365 if v.StartPeriod != nil { 3366 ok := object.Key("startPeriod") 3367 ok.Integer(*v.StartPeriod) 3368 } 3369 3370 if v.Timeout != nil { 3371 ok := object.Key("timeout") 3372 ok.Integer(*v.Timeout) 3373 } 3374 3375 return nil 3376} 3377 3378func awsAwsjson11_serializeDocumentHostEntry(v *types.HostEntry, value smithyjson.Value) error { 3379 object := value.Object() 3380 defer object.Close() 3381 3382 if v.Hostname != nil { 3383 ok := object.Key("hostname") 3384 ok.String(*v.Hostname) 3385 } 3386 3387 if v.IpAddress != nil { 3388 ok := object.Key("ipAddress") 3389 ok.String(*v.IpAddress) 3390 } 3391 3392 return nil 3393} 3394 3395func awsAwsjson11_serializeDocumentHostEntryList(v []types.HostEntry, value smithyjson.Value) error { 3396 array := value.Array() 3397 defer array.Close() 3398 3399 for i := range v { 3400 av := array.Value() 3401 if err := awsAwsjson11_serializeDocumentHostEntry(&v[i], av); err != nil { 3402 return err 3403 } 3404 } 3405 return nil 3406} 3407 3408func awsAwsjson11_serializeDocumentHostVolumeProperties(v *types.HostVolumeProperties, value smithyjson.Value) error { 3409 object := value.Object() 3410 defer object.Close() 3411 3412 if v.SourcePath != nil { 3413 ok := object.Key("sourcePath") 3414 ok.String(*v.SourcePath) 3415 } 3416 3417 return nil 3418} 3419 3420func awsAwsjson11_serializeDocumentInferenceAccelerator(v *types.InferenceAccelerator, value smithyjson.Value) error { 3421 object := value.Object() 3422 defer object.Close() 3423 3424 if v.DeviceName != nil { 3425 ok := object.Key("deviceName") 3426 ok.String(*v.DeviceName) 3427 } 3428 3429 if v.DeviceType != nil { 3430 ok := object.Key("deviceType") 3431 ok.String(*v.DeviceType) 3432 } 3433 3434 return nil 3435} 3436 3437func awsAwsjson11_serializeDocumentInferenceAcceleratorOverride(v *types.InferenceAcceleratorOverride, value smithyjson.Value) error { 3438 object := value.Object() 3439 defer object.Close() 3440 3441 if v.DeviceName != nil { 3442 ok := object.Key("deviceName") 3443 ok.String(*v.DeviceName) 3444 } 3445 3446 if v.DeviceType != nil { 3447 ok := object.Key("deviceType") 3448 ok.String(*v.DeviceType) 3449 } 3450 3451 return nil 3452} 3453 3454func awsAwsjson11_serializeDocumentInferenceAcceleratorOverrides(v []types.InferenceAcceleratorOverride, value smithyjson.Value) error { 3455 array := value.Array() 3456 defer array.Close() 3457 3458 for i := range v { 3459 av := array.Value() 3460 if err := awsAwsjson11_serializeDocumentInferenceAcceleratorOverride(&v[i], av); err != nil { 3461 return err 3462 } 3463 } 3464 return nil 3465} 3466 3467func awsAwsjson11_serializeDocumentInferenceAccelerators(v []types.InferenceAccelerator, value smithyjson.Value) error { 3468 array := value.Array() 3469 defer array.Close() 3470 3471 for i := range v { 3472 av := array.Value() 3473 if err := awsAwsjson11_serializeDocumentInferenceAccelerator(&v[i], av); err != nil { 3474 return err 3475 } 3476 } 3477 return nil 3478} 3479 3480func awsAwsjson11_serializeDocumentKernelCapabilities(v *types.KernelCapabilities, value smithyjson.Value) error { 3481 object := value.Object() 3482 defer object.Close() 3483 3484 if v.Add != nil { 3485 ok := object.Key("add") 3486 if err := awsAwsjson11_serializeDocumentStringList(v.Add, ok); err != nil { 3487 return err 3488 } 3489 } 3490 3491 if v.Drop != nil { 3492 ok := object.Key("drop") 3493 if err := awsAwsjson11_serializeDocumentStringList(v.Drop, ok); err != nil { 3494 return err 3495 } 3496 } 3497 3498 return nil 3499} 3500 3501func awsAwsjson11_serializeDocumentKeyValuePair(v *types.KeyValuePair, value smithyjson.Value) error { 3502 object := value.Object() 3503 defer object.Close() 3504 3505 if v.Name != nil { 3506 ok := object.Key("name") 3507 ok.String(*v.Name) 3508 } 3509 3510 if v.Value != nil { 3511 ok := object.Key("value") 3512 ok.String(*v.Value) 3513 } 3514 3515 return nil 3516} 3517 3518func awsAwsjson11_serializeDocumentLinuxParameters(v *types.LinuxParameters, value smithyjson.Value) error { 3519 object := value.Object() 3520 defer object.Close() 3521 3522 if v.Capabilities != nil { 3523 ok := object.Key("capabilities") 3524 if err := awsAwsjson11_serializeDocumentKernelCapabilities(v.Capabilities, ok); err != nil { 3525 return err 3526 } 3527 } 3528 3529 if v.Devices != nil { 3530 ok := object.Key("devices") 3531 if err := awsAwsjson11_serializeDocumentDevicesList(v.Devices, ok); err != nil { 3532 return err 3533 } 3534 } 3535 3536 if v.InitProcessEnabled != nil { 3537 ok := object.Key("initProcessEnabled") 3538 ok.Boolean(*v.InitProcessEnabled) 3539 } 3540 3541 if v.MaxSwap != nil { 3542 ok := object.Key("maxSwap") 3543 ok.Integer(*v.MaxSwap) 3544 } 3545 3546 if v.SharedMemorySize != nil { 3547 ok := object.Key("sharedMemorySize") 3548 ok.Integer(*v.SharedMemorySize) 3549 } 3550 3551 if v.Swappiness != nil { 3552 ok := object.Key("swappiness") 3553 ok.Integer(*v.Swappiness) 3554 } 3555 3556 if v.Tmpfs != nil { 3557 ok := object.Key("tmpfs") 3558 if err := awsAwsjson11_serializeDocumentTmpfsList(v.Tmpfs, ok); err != nil { 3559 return err 3560 } 3561 } 3562 3563 return nil 3564} 3565 3566func awsAwsjson11_serializeDocumentLoadBalancer(v *types.LoadBalancer, value smithyjson.Value) error { 3567 object := value.Object() 3568 defer object.Close() 3569 3570 if v.ContainerName != nil { 3571 ok := object.Key("containerName") 3572 ok.String(*v.ContainerName) 3573 } 3574 3575 if v.ContainerPort != nil { 3576 ok := object.Key("containerPort") 3577 ok.Integer(*v.ContainerPort) 3578 } 3579 3580 if v.LoadBalancerName != nil { 3581 ok := object.Key("loadBalancerName") 3582 ok.String(*v.LoadBalancerName) 3583 } 3584 3585 if v.TargetGroupArn != nil { 3586 ok := object.Key("targetGroupArn") 3587 ok.String(*v.TargetGroupArn) 3588 } 3589 3590 return nil 3591} 3592 3593func awsAwsjson11_serializeDocumentLoadBalancers(v []types.LoadBalancer, value smithyjson.Value) error { 3594 array := value.Array() 3595 defer array.Close() 3596 3597 for i := range v { 3598 av := array.Value() 3599 if err := awsAwsjson11_serializeDocumentLoadBalancer(&v[i], av); err != nil { 3600 return err 3601 } 3602 } 3603 return nil 3604} 3605 3606func awsAwsjson11_serializeDocumentLogConfiguration(v *types.LogConfiguration, value smithyjson.Value) error { 3607 object := value.Object() 3608 defer object.Close() 3609 3610 if len(v.LogDriver) > 0 { 3611 ok := object.Key("logDriver") 3612 ok.String(string(v.LogDriver)) 3613 } 3614 3615 if v.Options != nil { 3616 ok := object.Key("options") 3617 if err := awsAwsjson11_serializeDocumentLogConfigurationOptionsMap(v.Options, ok); err != nil { 3618 return err 3619 } 3620 } 3621 3622 if v.SecretOptions != nil { 3623 ok := object.Key("secretOptions") 3624 if err := awsAwsjson11_serializeDocumentSecretList(v.SecretOptions, ok); err != nil { 3625 return err 3626 } 3627 } 3628 3629 return nil 3630} 3631 3632func awsAwsjson11_serializeDocumentLogConfigurationOptionsMap(v map[string]string, value smithyjson.Value) error { 3633 object := value.Object() 3634 defer object.Close() 3635 3636 for key := range v { 3637 om := object.Key(key) 3638 om.String(v[key]) 3639 } 3640 return nil 3641} 3642 3643func awsAwsjson11_serializeDocumentManagedScaling(v *types.ManagedScaling, value smithyjson.Value) error { 3644 object := value.Object() 3645 defer object.Close() 3646 3647 if v.InstanceWarmupPeriod != nil { 3648 ok := object.Key("instanceWarmupPeriod") 3649 ok.Integer(*v.InstanceWarmupPeriod) 3650 } 3651 3652 if v.MaximumScalingStepSize != nil { 3653 ok := object.Key("maximumScalingStepSize") 3654 ok.Integer(*v.MaximumScalingStepSize) 3655 } 3656 3657 if v.MinimumScalingStepSize != nil { 3658 ok := object.Key("minimumScalingStepSize") 3659 ok.Integer(*v.MinimumScalingStepSize) 3660 } 3661 3662 if len(v.Status) > 0 { 3663 ok := object.Key("status") 3664 ok.String(string(v.Status)) 3665 } 3666 3667 if v.TargetCapacity != nil { 3668 ok := object.Key("targetCapacity") 3669 ok.Integer(*v.TargetCapacity) 3670 } 3671 3672 return nil 3673} 3674 3675func awsAwsjson11_serializeDocumentMountPoint(v *types.MountPoint, value smithyjson.Value) error { 3676 object := value.Object() 3677 defer object.Close() 3678 3679 if v.ContainerPath != nil { 3680 ok := object.Key("containerPath") 3681 ok.String(*v.ContainerPath) 3682 } 3683 3684 if v.ReadOnly != nil { 3685 ok := object.Key("readOnly") 3686 ok.Boolean(*v.ReadOnly) 3687 } 3688 3689 if v.SourceVolume != nil { 3690 ok := object.Key("sourceVolume") 3691 ok.String(*v.SourceVolume) 3692 } 3693 3694 return nil 3695} 3696 3697func awsAwsjson11_serializeDocumentMountPointList(v []types.MountPoint, value smithyjson.Value) error { 3698 array := value.Array() 3699 defer array.Close() 3700 3701 for i := range v { 3702 av := array.Value() 3703 if err := awsAwsjson11_serializeDocumentMountPoint(&v[i], av); err != nil { 3704 return err 3705 } 3706 } 3707 return nil 3708} 3709 3710func awsAwsjson11_serializeDocumentNetworkBinding(v *types.NetworkBinding, value smithyjson.Value) error { 3711 object := value.Object() 3712 defer object.Close() 3713 3714 if v.BindIP != nil { 3715 ok := object.Key("bindIP") 3716 ok.String(*v.BindIP) 3717 } 3718 3719 if v.ContainerPort != nil { 3720 ok := object.Key("containerPort") 3721 ok.Integer(*v.ContainerPort) 3722 } 3723 3724 if v.HostPort != nil { 3725 ok := object.Key("hostPort") 3726 ok.Integer(*v.HostPort) 3727 } 3728 3729 if len(v.Protocol) > 0 { 3730 ok := object.Key("protocol") 3731 ok.String(string(v.Protocol)) 3732 } 3733 3734 return nil 3735} 3736 3737func awsAwsjson11_serializeDocumentNetworkBindings(v []types.NetworkBinding, value smithyjson.Value) error { 3738 array := value.Array() 3739 defer array.Close() 3740 3741 for i := range v { 3742 av := array.Value() 3743 if err := awsAwsjson11_serializeDocumentNetworkBinding(&v[i], av); err != nil { 3744 return err 3745 } 3746 } 3747 return nil 3748} 3749 3750func awsAwsjson11_serializeDocumentNetworkConfiguration(v *types.NetworkConfiguration, value smithyjson.Value) error { 3751 object := value.Object() 3752 defer object.Close() 3753 3754 if v.AwsvpcConfiguration != nil { 3755 ok := object.Key("awsvpcConfiguration") 3756 if err := awsAwsjson11_serializeDocumentAwsVpcConfiguration(v.AwsvpcConfiguration, ok); err != nil { 3757 return err 3758 } 3759 } 3760 3761 return nil 3762} 3763 3764func awsAwsjson11_serializeDocumentPlacementConstraint(v *types.PlacementConstraint, value smithyjson.Value) error { 3765 object := value.Object() 3766 defer object.Close() 3767 3768 if v.Expression != nil { 3769 ok := object.Key("expression") 3770 ok.String(*v.Expression) 3771 } 3772 3773 if len(v.Type) > 0 { 3774 ok := object.Key("type") 3775 ok.String(string(v.Type)) 3776 } 3777 3778 return nil 3779} 3780 3781func awsAwsjson11_serializeDocumentPlacementConstraints(v []types.PlacementConstraint, value smithyjson.Value) error { 3782 array := value.Array() 3783 defer array.Close() 3784 3785 for i := range v { 3786 av := array.Value() 3787 if err := awsAwsjson11_serializeDocumentPlacementConstraint(&v[i], av); err != nil { 3788 return err 3789 } 3790 } 3791 return nil 3792} 3793 3794func awsAwsjson11_serializeDocumentPlacementStrategies(v []types.PlacementStrategy, value smithyjson.Value) error { 3795 array := value.Array() 3796 defer array.Close() 3797 3798 for i := range v { 3799 av := array.Value() 3800 if err := awsAwsjson11_serializeDocumentPlacementStrategy(&v[i], av); err != nil { 3801 return err 3802 } 3803 } 3804 return nil 3805} 3806 3807func awsAwsjson11_serializeDocumentPlacementStrategy(v *types.PlacementStrategy, value smithyjson.Value) error { 3808 object := value.Object() 3809 defer object.Close() 3810 3811 if v.Field != nil { 3812 ok := object.Key("field") 3813 ok.String(*v.Field) 3814 } 3815 3816 if len(v.Type) > 0 { 3817 ok := object.Key("type") 3818 ok.String(string(v.Type)) 3819 } 3820 3821 return nil 3822} 3823 3824func awsAwsjson11_serializeDocumentPlatformDevice(v *types.PlatformDevice, value smithyjson.Value) error { 3825 object := value.Object() 3826 defer object.Close() 3827 3828 if v.Id != nil { 3829 ok := object.Key("id") 3830 ok.String(*v.Id) 3831 } 3832 3833 if len(v.Type) > 0 { 3834 ok := object.Key("type") 3835 ok.String(string(v.Type)) 3836 } 3837 3838 return nil 3839} 3840 3841func awsAwsjson11_serializeDocumentPlatformDevices(v []types.PlatformDevice, value smithyjson.Value) error { 3842 array := value.Array() 3843 defer array.Close() 3844 3845 for i := range v { 3846 av := array.Value() 3847 if err := awsAwsjson11_serializeDocumentPlatformDevice(&v[i], av); err != nil { 3848 return err 3849 } 3850 } 3851 return nil 3852} 3853 3854func awsAwsjson11_serializeDocumentPortMapping(v *types.PortMapping, value smithyjson.Value) error { 3855 object := value.Object() 3856 defer object.Close() 3857 3858 if v.ContainerPort != nil { 3859 ok := object.Key("containerPort") 3860 ok.Integer(*v.ContainerPort) 3861 } 3862 3863 if v.HostPort != nil { 3864 ok := object.Key("hostPort") 3865 ok.Integer(*v.HostPort) 3866 } 3867 3868 if len(v.Protocol) > 0 { 3869 ok := object.Key("protocol") 3870 ok.String(string(v.Protocol)) 3871 } 3872 3873 return nil 3874} 3875 3876func awsAwsjson11_serializeDocumentPortMappingList(v []types.PortMapping, value smithyjson.Value) error { 3877 array := value.Array() 3878 defer array.Close() 3879 3880 for i := range v { 3881 av := array.Value() 3882 if err := awsAwsjson11_serializeDocumentPortMapping(&v[i], av); err != nil { 3883 return err 3884 } 3885 } 3886 return nil 3887} 3888 3889func awsAwsjson11_serializeDocumentProxyConfiguration(v *types.ProxyConfiguration, value smithyjson.Value) error { 3890 object := value.Object() 3891 defer object.Close() 3892 3893 if v.ContainerName != nil { 3894 ok := object.Key("containerName") 3895 ok.String(*v.ContainerName) 3896 } 3897 3898 if v.Properties != nil { 3899 ok := object.Key("properties") 3900 if err := awsAwsjson11_serializeDocumentProxyConfigurationProperties(v.Properties, ok); err != nil { 3901 return err 3902 } 3903 } 3904 3905 if len(v.Type) > 0 { 3906 ok := object.Key("type") 3907 ok.String(string(v.Type)) 3908 } 3909 3910 return nil 3911} 3912 3913func awsAwsjson11_serializeDocumentProxyConfigurationProperties(v []types.KeyValuePair, value smithyjson.Value) error { 3914 array := value.Array() 3915 defer array.Close() 3916 3917 for i := range v { 3918 av := array.Value() 3919 if err := awsAwsjson11_serializeDocumentKeyValuePair(&v[i], av); err != nil { 3920 return err 3921 } 3922 } 3923 return nil 3924} 3925 3926func awsAwsjson11_serializeDocumentRepositoryCredentials(v *types.RepositoryCredentials, value smithyjson.Value) error { 3927 object := value.Object() 3928 defer object.Close() 3929 3930 if v.CredentialsParameter != nil { 3931 ok := object.Key("credentialsParameter") 3932 ok.String(*v.CredentialsParameter) 3933 } 3934 3935 return nil 3936} 3937 3938func awsAwsjson11_serializeDocumentResource(v *types.Resource, value smithyjson.Value) error { 3939 object := value.Object() 3940 defer object.Close() 3941 3942 if v.DoubleValue != 0 { 3943 ok := object.Key("doubleValue") 3944 ok.Double(v.DoubleValue) 3945 } 3946 3947 if v.IntegerValue != 0 { 3948 ok := object.Key("integerValue") 3949 ok.Integer(v.IntegerValue) 3950 } 3951 3952 if v.LongValue != 0 { 3953 ok := object.Key("longValue") 3954 ok.Long(v.LongValue) 3955 } 3956 3957 if v.Name != nil { 3958 ok := object.Key("name") 3959 ok.String(*v.Name) 3960 } 3961 3962 if v.StringSetValue != nil { 3963 ok := object.Key("stringSetValue") 3964 if err := awsAwsjson11_serializeDocumentStringList(v.StringSetValue, ok); err != nil { 3965 return err 3966 } 3967 } 3968 3969 if v.Type != nil { 3970 ok := object.Key("type") 3971 ok.String(*v.Type) 3972 } 3973 3974 return nil 3975} 3976 3977func awsAwsjson11_serializeDocumentResourceRequirement(v *types.ResourceRequirement, value smithyjson.Value) error { 3978 object := value.Object() 3979 defer object.Close() 3980 3981 if len(v.Type) > 0 { 3982 ok := object.Key("type") 3983 ok.String(string(v.Type)) 3984 } 3985 3986 if v.Value != nil { 3987 ok := object.Key("value") 3988 ok.String(*v.Value) 3989 } 3990 3991 return nil 3992} 3993 3994func awsAwsjson11_serializeDocumentResourceRequirements(v []types.ResourceRequirement, value smithyjson.Value) error { 3995 array := value.Array() 3996 defer array.Close() 3997 3998 for i := range v { 3999 av := array.Value() 4000 if err := awsAwsjson11_serializeDocumentResourceRequirement(&v[i], av); err != nil { 4001 return err 4002 } 4003 } 4004 return nil 4005} 4006 4007func awsAwsjson11_serializeDocumentResources(v []types.Resource, value smithyjson.Value) error { 4008 array := value.Array() 4009 defer array.Close() 4010 4011 for i := range v { 4012 av := array.Value() 4013 if err := awsAwsjson11_serializeDocumentResource(&v[i], av); err != nil { 4014 return err 4015 } 4016 } 4017 return nil 4018} 4019 4020func awsAwsjson11_serializeDocumentScale(v *types.Scale, value smithyjson.Value) error { 4021 object := value.Object() 4022 defer object.Close() 4023 4024 if len(v.Unit) > 0 { 4025 ok := object.Key("unit") 4026 ok.String(string(v.Unit)) 4027 } 4028 4029 if v.Value != 0 { 4030 ok := object.Key("value") 4031 ok.Double(v.Value) 4032 } 4033 4034 return nil 4035} 4036 4037func awsAwsjson11_serializeDocumentSecret(v *types.Secret, value smithyjson.Value) error { 4038 object := value.Object() 4039 defer object.Close() 4040 4041 if v.Name != nil { 4042 ok := object.Key("name") 4043 ok.String(*v.Name) 4044 } 4045 4046 if v.ValueFrom != nil { 4047 ok := object.Key("valueFrom") 4048 ok.String(*v.ValueFrom) 4049 } 4050 4051 return nil 4052} 4053 4054func awsAwsjson11_serializeDocumentSecretList(v []types.Secret, value smithyjson.Value) error { 4055 array := value.Array() 4056 defer array.Close() 4057 4058 for i := range v { 4059 av := array.Value() 4060 if err := awsAwsjson11_serializeDocumentSecret(&v[i], av); err != nil { 4061 return err 4062 } 4063 } 4064 return nil 4065} 4066 4067func awsAwsjson11_serializeDocumentServiceFieldList(v []types.ServiceField, value smithyjson.Value) error { 4068 array := value.Array() 4069 defer array.Close() 4070 4071 for i := range v { 4072 av := array.Value() 4073 av.String(string(v[i])) 4074 } 4075 return nil 4076} 4077 4078func awsAwsjson11_serializeDocumentServiceRegistries(v []types.ServiceRegistry, value smithyjson.Value) error { 4079 array := value.Array() 4080 defer array.Close() 4081 4082 for i := range v { 4083 av := array.Value() 4084 if err := awsAwsjson11_serializeDocumentServiceRegistry(&v[i], av); err != nil { 4085 return err 4086 } 4087 } 4088 return nil 4089} 4090 4091func awsAwsjson11_serializeDocumentServiceRegistry(v *types.ServiceRegistry, value smithyjson.Value) error { 4092 object := value.Object() 4093 defer object.Close() 4094 4095 if v.ContainerName != nil { 4096 ok := object.Key("containerName") 4097 ok.String(*v.ContainerName) 4098 } 4099 4100 if v.ContainerPort != nil { 4101 ok := object.Key("containerPort") 4102 ok.Integer(*v.ContainerPort) 4103 } 4104 4105 if v.Port != nil { 4106 ok := object.Key("port") 4107 ok.Integer(*v.Port) 4108 } 4109 4110 if v.RegistryArn != nil { 4111 ok := object.Key("registryArn") 4112 ok.String(*v.RegistryArn) 4113 } 4114 4115 return nil 4116} 4117 4118func awsAwsjson11_serializeDocumentStringList(v []string, value smithyjson.Value) error { 4119 array := value.Array() 4120 defer array.Close() 4121 4122 for i := range v { 4123 av := array.Value() 4124 av.String(v[i]) 4125 } 4126 return nil 4127} 4128 4129func awsAwsjson11_serializeDocumentStringMap(v map[string]string, value smithyjson.Value) error { 4130 object := value.Object() 4131 defer object.Close() 4132 4133 for key := range v { 4134 om := object.Key(key) 4135 om.String(v[key]) 4136 } 4137 return nil 4138} 4139 4140func awsAwsjson11_serializeDocumentSystemControl(v *types.SystemControl, value smithyjson.Value) error { 4141 object := value.Object() 4142 defer object.Close() 4143 4144 if v.Namespace != nil { 4145 ok := object.Key("namespace") 4146 ok.String(*v.Namespace) 4147 } 4148 4149 if v.Value != nil { 4150 ok := object.Key("value") 4151 ok.String(*v.Value) 4152 } 4153 4154 return nil 4155} 4156 4157func awsAwsjson11_serializeDocumentSystemControls(v []types.SystemControl, value smithyjson.Value) error { 4158 array := value.Array() 4159 defer array.Close() 4160 4161 for i := range v { 4162 av := array.Value() 4163 if err := awsAwsjson11_serializeDocumentSystemControl(&v[i], av); err != nil { 4164 return err 4165 } 4166 } 4167 return nil 4168} 4169 4170func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 4171 object := value.Object() 4172 defer object.Close() 4173 4174 if v.Key != nil { 4175 ok := object.Key("key") 4176 ok.String(*v.Key) 4177 } 4178 4179 if v.Value != nil { 4180 ok := object.Key("value") 4181 ok.String(*v.Value) 4182 } 4183 4184 return nil 4185} 4186 4187func awsAwsjson11_serializeDocumentTagKeys(v []string, value smithyjson.Value) error { 4188 array := value.Array() 4189 defer array.Close() 4190 4191 for i := range v { 4192 av := array.Value() 4193 av.String(v[i]) 4194 } 4195 return nil 4196} 4197 4198func awsAwsjson11_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error { 4199 array := value.Array() 4200 defer array.Close() 4201 4202 for i := range v { 4203 av := array.Value() 4204 if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil { 4205 return err 4206 } 4207 } 4208 return nil 4209} 4210 4211func awsAwsjson11_serializeDocumentTaskDefinitionFieldList(v []types.TaskDefinitionField, value smithyjson.Value) error { 4212 array := value.Array() 4213 defer array.Close() 4214 4215 for i := range v { 4216 av := array.Value() 4217 av.String(string(v[i])) 4218 } 4219 return nil 4220} 4221 4222func awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraint(v *types.TaskDefinitionPlacementConstraint, value smithyjson.Value) error { 4223 object := value.Object() 4224 defer object.Close() 4225 4226 if v.Expression != nil { 4227 ok := object.Key("expression") 4228 ok.String(*v.Expression) 4229 } 4230 4231 if len(v.Type) > 0 { 4232 ok := object.Key("type") 4233 ok.String(string(v.Type)) 4234 } 4235 4236 return nil 4237} 4238 4239func awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraints(v []types.TaskDefinitionPlacementConstraint, value smithyjson.Value) error { 4240 array := value.Array() 4241 defer array.Close() 4242 4243 for i := range v { 4244 av := array.Value() 4245 if err := awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraint(&v[i], av); err != nil { 4246 return err 4247 } 4248 } 4249 return nil 4250} 4251 4252func awsAwsjson11_serializeDocumentTaskFieldList(v []types.TaskField, value smithyjson.Value) error { 4253 array := value.Array() 4254 defer array.Close() 4255 4256 for i := range v { 4257 av := array.Value() 4258 av.String(string(v[i])) 4259 } 4260 return nil 4261} 4262 4263func awsAwsjson11_serializeDocumentTaskOverride(v *types.TaskOverride, value smithyjson.Value) error { 4264 object := value.Object() 4265 defer object.Close() 4266 4267 if v.ContainerOverrides != nil { 4268 ok := object.Key("containerOverrides") 4269 if err := awsAwsjson11_serializeDocumentContainerOverrides(v.ContainerOverrides, ok); err != nil { 4270 return err 4271 } 4272 } 4273 4274 if v.Cpu != nil { 4275 ok := object.Key("cpu") 4276 ok.String(*v.Cpu) 4277 } 4278 4279 if v.ExecutionRoleArn != nil { 4280 ok := object.Key("executionRoleArn") 4281 ok.String(*v.ExecutionRoleArn) 4282 } 4283 4284 if v.InferenceAcceleratorOverrides != nil { 4285 ok := object.Key("inferenceAcceleratorOverrides") 4286 if err := awsAwsjson11_serializeDocumentInferenceAcceleratorOverrides(v.InferenceAcceleratorOverrides, ok); err != nil { 4287 return err 4288 } 4289 } 4290 4291 if v.Memory != nil { 4292 ok := object.Key("memory") 4293 ok.String(*v.Memory) 4294 } 4295 4296 if v.TaskRoleArn != nil { 4297 ok := object.Key("taskRoleArn") 4298 ok.String(*v.TaskRoleArn) 4299 } 4300 4301 return nil 4302} 4303 4304func awsAwsjson11_serializeDocumentTaskSetFieldList(v []types.TaskSetField, value smithyjson.Value) error { 4305 array := value.Array() 4306 defer array.Close() 4307 4308 for i := range v { 4309 av := array.Value() 4310 av.String(string(v[i])) 4311 } 4312 return nil 4313} 4314 4315func awsAwsjson11_serializeDocumentTmpfs(v *types.Tmpfs, value smithyjson.Value) error { 4316 object := value.Object() 4317 defer object.Close() 4318 4319 if v.ContainerPath != nil { 4320 ok := object.Key("containerPath") 4321 ok.String(*v.ContainerPath) 4322 } 4323 4324 if v.MountOptions != nil { 4325 ok := object.Key("mountOptions") 4326 if err := awsAwsjson11_serializeDocumentStringList(v.MountOptions, ok); err != nil { 4327 return err 4328 } 4329 } 4330 4331 if v.Size != 0 { 4332 ok := object.Key("size") 4333 ok.Integer(v.Size) 4334 } 4335 4336 return nil 4337} 4338 4339func awsAwsjson11_serializeDocumentTmpfsList(v []types.Tmpfs, value smithyjson.Value) error { 4340 array := value.Array() 4341 defer array.Close() 4342 4343 for i := range v { 4344 av := array.Value() 4345 if err := awsAwsjson11_serializeDocumentTmpfs(&v[i], av); err != nil { 4346 return err 4347 } 4348 } 4349 return nil 4350} 4351 4352func awsAwsjson11_serializeDocumentUlimit(v *types.Ulimit, value smithyjson.Value) error { 4353 object := value.Object() 4354 defer object.Close() 4355 4356 if v.HardLimit != 0 { 4357 ok := object.Key("hardLimit") 4358 ok.Integer(v.HardLimit) 4359 } 4360 4361 if len(v.Name) > 0 { 4362 ok := object.Key("name") 4363 ok.String(string(v.Name)) 4364 } 4365 4366 if v.SoftLimit != 0 { 4367 ok := object.Key("softLimit") 4368 ok.Integer(v.SoftLimit) 4369 } 4370 4371 return nil 4372} 4373 4374func awsAwsjson11_serializeDocumentUlimitList(v []types.Ulimit, value smithyjson.Value) error { 4375 array := value.Array() 4376 defer array.Close() 4377 4378 for i := range v { 4379 av := array.Value() 4380 if err := awsAwsjson11_serializeDocumentUlimit(&v[i], av); err != nil { 4381 return err 4382 } 4383 } 4384 return nil 4385} 4386 4387func awsAwsjson11_serializeDocumentVersionInfo(v *types.VersionInfo, value smithyjson.Value) error { 4388 object := value.Object() 4389 defer object.Close() 4390 4391 if v.AgentHash != nil { 4392 ok := object.Key("agentHash") 4393 ok.String(*v.AgentHash) 4394 } 4395 4396 if v.AgentVersion != nil { 4397 ok := object.Key("agentVersion") 4398 ok.String(*v.AgentVersion) 4399 } 4400 4401 if v.DockerVersion != nil { 4402 ok := object.Key("dockerVersion") 4403 ok.String(*v.DockerVersion) 4404 } 4405 4406 return nil 4407} 4408 4409func awsAwsjson11_serializeDocumentVolume(v *types.Volume, value smithyjson.Value) error { 4410 object := value.Object() 4411 defer object.Close() 4412 4413 if v.DockerVolumeConfiguration != nil { 4414 ok := object.Key("dockerVolumeConfiguration") 4415 if err := awsAwsjson11_serializeDocumentDockerVolumeConfiguration(v.DockerVolumeConfiguration, ok); err != nil { 4416 return err 4417 } 4418 } 4419 4420 if v.EfsVolumeConfiguration != nil { 4421 ok := object.Key("efsVolumeConfiguration") 4422 if err := awsAwsjson11_serializeDocumentEFSVolumeConfiguration(v.EfsVolumeConfiguration, ok); err != nil { 4423 return err 4424 } 4425 } 4426 4427 if v.FsxWindowsFileServerVolumeConfiguration != nil { 4428 ok := object.Key("fsxWindowsFileServerVolumeConfiguration") 4429 if err := awsAwsjson11_serializeDocumentFSxWindowsFileServerVolumeConfiguration(v.FsxWindowsFileServerVolumeConfiguration, ok); err != nil { 4430 return err 4431 } 4432 } 4433 4434 if v.Host != nil { 4435 ok := object.Key("host") 4436 if err := awsAwsjson11_serializeDocumentHostVolumeProperties(v.Host, ok); err != nil { 4437 return err 4438 } 4439 } 4440 4441 if v.Name != nil { 4442 ok := object.Key("name") 4443 ok.String(*v.Name) 4444 } 4445 4446 return nil 4447} 4448 4449func awsAwsjson11_serializeDocumentVolumeFrom(v *types.VolumeFrom, value smithyjson.Value) error { 4450 object := value.Object() 4451 defer object.Close() 4452 4453 if v.ReadOnly != nil { 4454 ok := object.Key("readOnly") 4455 ok.Boolean(*v.ReadOnly) 4456 } 4457 4458 if v.SourceContainer != nil { 4459 ok := object.Key("sourceContainer") 4460 ok.String(*v.SourceContainer) 4461 } 4462 4463 return nil 4464} 4465 4466func awsAwsjson11_serializeDocumentVolumeFromList(v []types.VolumeFrom, value smithyjson.Value) error { 4467 array := value.Array() 4468 defer array.Close() 4469 4470 for i := range v { 4471 av := array.Value() 4472 if err := awsAwsjson11_serializeDocumentVolumeFrom(&v[i], av); err != nil { 4473 return err 4474 } 4475 } 4476 return nil 4477} 4478 4479func awsAwsjson11_serializeDocumentVolumeList(v []types.Volume, value smithyjson.Value) error { 4480 array := value.Array() 4481 defer array.Close() 4482 4483 for i := range v { 4484 av := array.Value() 4485 if err := awsAwsjson11_serializeDocumentVolume(&v[i], av); err != nil { 4486 return err 4487 } 4488 } 4489 return nil 4490} 4491 4492func awsAwsjson11_serializeOpDocumentCreateCapacityProviderInput(v *CreateCapacityProviderInput, value smithyjson.Value) error { 4493 object := value.Object() 4494 defer object.Close() 4495 4496 if v.AutoScalingGroupProvider != nil { 4497 ok := object.Key("autoScalingGroupProvider") 4498 if err := awsAwsjson11_serializeDocumentAutoScalingGroupProvider(v.AutoScalingGroupProvider, ok); err != nil { 4499 return err 4500 } 4501 } 4502 4503 if v.Name != nil { 4504 ok := object.Key("name") 4505 ok.String(*v.Name) 4506 } 4507 4508 if v.Tags != nil { 4509 ok := object.Key("tags") 4510 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 4511 return err 4512 } 4513 } 4514 4515 return nil 4516} 4517 4518func awsAwsjson11_serializeOpDocumentCreateClusterInput(v *CreateClusterInput, value smithyjson.Value) error { 4519 object := value.Object() 4520 defer object.Close() 4521 4522 if v.CapacityProviders != nil { 4523 ok := object.Key("capacityProviders") 4524 if err := awsAwsjson11_serializeDocumentStringList(v.CapacityProviders, ok); err != nil { 4525 return err 4526 } 4527 } 4528 4529 if v.ClusterName != nil { 4530 ok := object.Key("clusterName") 4531 ok.String(*v.ClusterName) 4532 } 4533 4534 if v.DefaultCapacityProviderStrategy != nil { 4535 ok := object.Key("defaultCapacityProviderStrategy") 4536 if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.DefaultCapacityProviderStrategy, ok); err != nil { 4537 return err 4538 } 4539 } 4540 4541 if v.Settings != nil { 4542 ok := object.Key("settings") 4543 if err := awsAwsjson11_serializeDocumentClusterSettings(v.Settings, ok); err != nil { 4544 return err 4545 } 4546 } 4547 4548 if v.Tags != nil { 4549 ok := object.Key("tags") 4550 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 4551 return err 4552 } 4553 } 4554 4555 return nil 4556} 4557 4558func awsAwsjson11_serializeOpDocumentCreateServiceInput(v *CreateServiceInput, value smithyjson.Value) error { 4559 object := value.Object() 4560 defer object.Close() 4561 4562 if v.CapacityProviderStrategy != nil { 4563 ok := object.Key("capacityProviderStrategy") 4564 if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil { 4565 return err 4566 } 4567 } 4568 4569 if v.ClientToken != nil { 4570 ok := object.Key("clientToken") 4571 ok.String(*v.ClientToken) 4572 } 4573 4574 if v.Cluster != nil { 4575 ok := object.Key("cluster") 4576 ok.String(*v.Cluster) 4577 } 4578 4579 if v.DeploymentConfiguration != nil { 4580 ok := object.Key("deploymentConfiguration") 4581 if err := awsAwsjson11_serializeDocumentDeploymentConfiguration(v.DeploymentConfiguration, ok); err != nil { 4582 return err 4583 } 4584 } 4585 4586 if v.DeploymentController != nil { 4587 ok := object.Key("deploymentController") 4588 if err := awsAwsjson11_serializeDocumentDeploymentController(v.DeploymentController, ok); err != nil { 4589 return err 4590 } 4591 } 4592 4593 if v.DesiredCount != nil { 4594 ok := object.Key("desiredCount") 4595 ok.Integer(*v.DesiredCount) 4596 } 4597 4598 if v.EnableECSManagedTags { 4599 ok := object.Key("enableECSManagedTags") 4600 ok.Boolean(v.EnableECSManagedTags) 4601 } 4602 4603 if v.HealthCheckGracePeriodSeconds != nil { 4604 ok := object.Key("healthCheckGracePeriodSeconds") 4605 ok.Integer(*v.HealthCheckGracePeriodSeconds) 4606 } 4607 4608 if len(v.LaunchType) > 0 { 4609 ok := object.Key("launchType") 4610 ok.String(string(v.LaunchType)) 4611 } 4612 4613 if v.LoadBalancers != nil { 4614 ok := object.Key("loadBalancers") 4615 if err := awsAwsjson11_serializeDocumentLoadBalancers(v.LoadBalancers, ok); err != nil { 4616 return err 4617 } 4618 } 4619 4620 if v.NetworkConfiguration != nil { 4621 ok := object.Key("networkConfiguration") 4622 if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil { 4623 return err 4624 } 4625 } 4626 4627 if v.PlacementConstraints != nil { 4628 ok := object.Key("placementConstraints") 4629 if err := awsAwsjson11_serializeDocumentPlacementConstraints(v.PlacementConstraints, ok); err != nil { 4630 return err 4631 } 4632 } 4633 4634 if v.PlacementStrategy != nil { 4635 ok := object.Key("placementStrategy") 4636 if err := awsAwsjson11_serializeDocumentPlacementStrategies(v.PlacementStrategy, ok); err != nil { 4637 return err 4638 } 4639 } 4640 4641 if v.PlatformVersion != nil { 4642 ok := object.Key("platformVersion") 4643 ok.String(*v.PlatformVersion) 4644 } 4645 4646 if len(v.PropagateTags) > 0 { 4647 ok := object.Key("propagateTags") 4648 ok.String(string(v.PropagateTags)) 4649 } 4650 4651 if v.Role != nil { 4652 ok := object.Key("role") 4653 ok.String(*v.Role) 4654 } 4655 4656 if len(v.SchedulingStrategy) > 0 { 4657 ok := object.Key("schedulingStrategy") 4658 ok.String(string(v.SchedulingStrategy)) 4659 } 4660 4661 if v.ServiceName != nil { 4662 ok := object.Key("serviceName") 4663 ok.String(*v.ServiceName) 4664 } 4665 4666 if v.ServiceRegistries != nil { 4667 ok := object.Key("serviceRegistries") 4668 if err := awsAwsjson11_serializeDocumentServiceRegistries(v.ServiceRegistries, ok); err != nil { 4669 return err 4670 } 4671 } 4672 4673 if v.Tags != nil { 4674 ok := object.Key("tags") 4675 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 4676 return err 4677 } 4678 } 4679 4680 if v.TaskDefinition != nil { 4681 ok := object.Key("taskDefinition") 4682 ok.String(*v.TaskDefinition) 4683 } 4684 4685 return nil 4686} 4687 4688func awsAwsjson11_serializeOpDocumentCreateTaskSetInput(v *CreateTaskSetInput, value smithyjson.Value) error { 4689 object := value.Object() 4690 defer object.Close() 4691 4692 if v.CapacityProviderStrategy != nil { 4693 ok := object.Key("capacityProviderStrategy") 4694 if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil { 4695 return err 4696 } 4697 } 4698 4699 if v.ClientToken != nil { 4700 ok := object.Key("clientToken") 4701 ok.String(*v.ClientToken) 4702 } 4703 4704 if v.Cluster != nil { 4705 ok := object.Key("cluster") 4706 ok.String(*v.Cluster) 4707 } 4708 4709 if v.ExternalId != nil { 4710 ok := object.Key("externalId") 4711 ok.String(*v.ExternalId) 4712 } 4713 4714 if len(v.LaunchType) > 0 { 4715 ok := object.Key("launchType") 4716 ok.String(string(v.LaunchType)) 4717 } 4718 4719 if v.LoadBalancers != nil { 4720 ok := object.Key("loadBalancers") 4721 if err := awsAwsjson11_serializeDocumentLoadBalancers(v.LoadBalancers, ok); err != nil { 4722 return err 4723 } 4724 } 4725 4726 if v.NetworkConfiguration != nil { 4727 ok := object.Key("networkConfiguration") 4728 if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil { 4729 return err 4730 } 4731 } 4732 4733 if v.PlatformVersion != nil { 4734 ok := object.Key("platformVersion") 4735 ok.String(*v.PlatformVersion) 4736 } 4737 4738 if v.Scale != nil { 4739 ok := object.Key("scale") 4740 if err := awsAwsjson11_serializeDocumentScale(v.Scale, ok); err != nil { 4741 return err 4742 } 4743 } 4744 4745 if v.Service != nil { 4746 ok := object.Key("service") 4747 ok.String(*v.Service) 4748 } 4749 4750 if v.ServiceRegistries != nil { 4751 ok := object.Key("serviceRegistries") 4752 if err := awsAwsjson11_serializeDocumentServiceRegistries(v.ServiceRegistries, ok); err != nil { 4753 return err 4754 } 4755 } 4756 4757 if v.Tags != nil { 4758 ok := object.Key("tags") 4759 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 4760 return err 4761 } 4762 } 4763 4764 if v.TaskDefinition != nil { 4765 ok := object.Key("taskDefinition") 4766 ok.String(*v.TaskDefinition) 4767 } 4768 4769 return nil 4770} 4771 4772func awsAwsjson11_serializeOpDocumentDeleteAccountSettingInput(v *DeleteAccountSettingInput, value smithyjson.Value) error { 4773 object := value.Object() 4774 defer object.Close() 4775 4776 if len(v.Name) > 0 { 4777 ok := object.Key("name") 4778 ok.String(string(v.Name)) 4779 } 4780 4781 if v.PrincipalArn != nil { 4782 ok := object.Key("principalArn") 4783 ok.String(*v.PrincipalArn) 4784 } 4785 4786 return nil 4787} 4788 4789func awsAwsjson11_serializeOpDocumentDeleteAttributesInput(v *DeleteAttributesInput, value smithyjson.Value) error { 4790 object := value.Object() 4791 defer object.Close() 4792 4793 if v.Attributes != nil { 4794 ok := object.Key("attributes") 4795 if err := awsAwsjson11_serializeDocumentAttributes(v.Attributes, ok); err != nil { 4796 return err 4797 } 4798 } 4799 4800 if v.Cluster != nil { 4801 ok := object.Key("cluster") 4802 ok.String(*v.Cluster) 4803 } 4804 4805 return nil 4806} 4807 4808func awsAwsjson11_serializeOpDocumentDeleteCapacityProviderInput(v *DeleteCapacityProviderInput, value smithyjson.Value) error { 4809 object := value.Object() 4810 defer object.Close() 4811 4812 if v.CapacityProvider != nil { 4813 ok := object.Key("capacityProvider") 4814 ok.String(*v.CapacityProvider) 4815 } 4816 4817 return nil 4818} 4819 4820func awsAwsjson11_serializeOpDocumentDeleteClusterInput(v *DeleteClusterInput, value smithyjson.Value) error { 4821 object := value.Object() 4822 defer object.Close() 4823 4824 if v.Cluster != nil { 4825 ok := object.Key("cluster") 4826 ok.String(*v.Cluster) 4827 } 4828 4829 return nil 4830} 4831 4832func awsAwsjson11_serializeOpDocumentDeleteServiceInput(v *DeleteServiceInput, value smithyjson.Value) error { 4833 object := value.Object() 4834 defer object.Close() 4835 4836 if v.Cluster != nil { 4837 ok := object.Key("cluster") 4838 ok.String(*v.Cluster) 4839 } 4840 4841 if v.Force != nil { 4842 ok := object.Key("force") 4843 ok.Boolean(*v.Force) 4844 } 4845 4846 if v.Service != nil { 4847 ok := object.Key("service") 4848 ok.String(*v.Service) 4849 } 4850 4851 return nil 4852} 4853 4854func awsAwsjson11_serializeOpDocumentDeleteTaskSetInput(v *DeleteTaskSetInput, value smithyjson.Value) error { 4855 object := value.Object() 4856 defer object.Close() 4857 4858 if v.Cluster != nil { 4859 ok := object.Key("cluster") 4860 ok.String(*v.Cluster) 4861 } 4862 4863 if v.Force != nil { 4864 ok := object.Key("force") 4865 ok.Boolean(*v.Force) 4866 } 4867 4868 if v.Service != nil { 4869 ok := object.Key("service") 4870 ok.String(*v.Service) 4871 } 4872 4873 if v.TaskSet != nil { 4874 ok := object.Key("taskSet") 4875 ok.String(*v.TaskSet) 4876 } 4877 4878 return nil 4879} 4880 4881func awsAwsjson11_serializeOpDocumentDeregisterContainerInstanceInput(v *DeregisterContainerInstanceInput, value smithyjson.Value) error { 4882 object := value.Object() 4883 defer object.Close() 4884 4885 if v.Cluster != nil { 4886 ok := object.Key("cluster") 4887 ok.String(*v.Cluster) 4888 } 4889 4890 if v.ContainerInstance != nil { 4891 ok := object.Key("containerInstance") 4892 ok.String(*v.ContainerInstance) 4893 } 4894 4895 if v.Force != nil { 4896 ok := object.Key("force") 4897 ok.Boolean(*v.Force) 4898 } 4899 4900 return nil 4901} 4902 4903func awsAwsjson11_serializeOpDocumentDeregisterTaskDefinitionInput(v *DeregisterTaskDefinitionInput, value smithyjson.Value) error { 4904 object := value.Object() 4905 defer object.Close() 4906 4907 if v.TaskDefinition != nil { 4908 ok := object.Key("taskDefinition") 4909 ok.String(*v.TaskDefinition) 4910 } 4911 4912 return nil 4913} 4914 4915func awsAwsjson11_serializeOpDocumentDescribeCapacityProvidersInput(v *DescribeCapacityProvidersInput, value smithyjson.Value) error { 4916 object := value.Object() 4917 defer object.Close() 4918 4919 if v.CapacityProviders != nil { 4920 ok := object.Key("capacityProviders") 4921 if err := awsAwsjson11_serializeDocumentStringList(v.CapacityProviders, ok); err != nil { 4922 return err 4923 } 4924 } 4925 4926 if v.Include != nil { 4927 ok := object.Key("include") 4928 if err := awsAwsjson11_serializeDocumentCapacityProviderFieldList(v.Include, ok); err != nil { 4929 return err 4930 } 4931 } 4932 4933 if v.MaxResults != nil { 4934 ok := object.Key("maxResults") 4935 ok.Integer(*v.MaxResults) 4936 } 4937 4938 if v.NextToken != nil { 4939 ok := object.Key("nextToken") 4940 ok.String(*v.NextToken) 4941 } 4942 4943 return nil 4944} 4945 4946func awsAwsjson11_serializeOpDocumentDescribeClustersInput(v *DescribeClustersInput, value smithyjson.Value) error { 4947 object := value.Object() 4948 defer object.Close() 4949 4950 if v.Clusters != nil { 4951 ok := object.Key("clusters") 4952 if err := awsAwsjson11_serializeDocumentStringList(v.Clusters, ok); err != nil { 4953 return err 4954 } 4955 } 4956 4957 if v.Include != nil { 4958 ok := object.Key("include") 4959 if err := awsAwsjson11_serializeDocumentClusterFieldList(v.Include, ok); err != nil { 4960 return err 4961 } 4962 } 4963 4964 return nil 4965} 4966 4967func awsAwsjson11_serializeOpDocumentDescribeContainerInstancesInput(v *DescribeContainerInstancesInput, value smithyjson.Value) error { 4968 object := value.Object() 4969 defer object.Close() 4970 4971 if v.Cluster != nil { 4972 ok := object.Key("cluster") 4973 ok.String(*v.Cluster) 4974 } 4975 4976 if v.ContainerInstances != nil { 4977 ok := object.Key("containerInstances") 4978 if err := awsAwsjson11_serializeDocumentStringList(v.ContainerInstances, ok); err != nil { 4979 return err 4980 } 4981 } 4982 4983 if v.Include != nil { 4984 ok := object.Key("include") 4985 if err := awsAwsjson11_serializeDocumentContainerInstanceFieldList(v.Include, ok); err != nil { 4986 return err 4987 } 4988 } 4989 4990 return nil 4991} 4992 4993func awsAwsjson11_serializeOpDocumentDescribeServicesInput(v *DescribeServicesInput, value smithyjson.Value) error { 4994 object := value.Object() 4995 defer object.Close() 4996 4997 if v.Cluster != nil { 4998 ok := object.Key("cluster") 4999 ok.String(*v.Cluster) 5000 } 5001 5002 if v.Include != nil { 5003 ok := object.Key("include") 5004 if err := awsAwsjson11_serializeDocumentServiceFieldList(v.Include, ok); err != nil { 5005 return err 5006 } 5007 } 5008 5009 if v.Services != nil { 5010 ok := object.Key("services") 5011 if err := awsAwsjson11_serializeDocumentStringList(v.Services, ok); err != nil { 5012 return err 5013 } 5014 } 5015 5016 return nil 5017} 5018 5019func awsAwsjson11_serializeOpDocumentDescribeTaskDefinitionInput(v *DescribeTaskDefinitionInput, value smithyjson.Value) error { 5020 object := value.Object() 5021 defer object.Close() 5022 5023 if v.Include != nil { 5024 ok := object.Key("include") 5025 if err := awsAwsjson11_serializeDocumentTaskDefinitionFieldList(v.Include, ok); err != nil { 5026 return err 5027 } 5028 } 5029 5030 if v.TaskDefinition != nil { 5031 ok := object.Key("taskDefinition") 5032 ok.String(*v.TaskDefinition) 5033 } 5034 5035 return nil 5036} 5037 5038func awsAwsjson11_serializeOpDocumentDescribeTaskSetsInput(v *DescribeTaskSetsInput, value smithyjson.Value) error { 5039 object := value.Object() 5040 defer object.Close() 5041 5042 if v.Cluster != nil { 5043 ok := object.Key("cluster") 5044 ok.String(*v.Cluster) 5045 } 5046 5047 if v.Include != nil { 5048 ok := object.Key("include") 5049 if err := awsAwsjson11_serializeDocumentTaskSetFieldList(v.Include, ok); err != nil { 5050 return err 5051 } 5052 } 5053 5054 if v.Service != nil { 5055 ok := object.Key("service") 5056 ok.String(*v.Service) 5057 } 5058 5059 if v.TaskSets != nil { 5060 ok := object.Key("taskSets") 5061 if err := awsAwsjson11_serializeDocumentStringList(v.TaskSets, ok); err != nil { 5062 return err 5063 } 5064 } 5065 5066 return nil 5067} 5068 5069func awsAwsjson11_serializeOpDocumentDescribeTasksInput(v *DescribeTasksInput, value smithyjson.Value) error { 5070 object := value.Object() 5071 defer object.Close() 5072 5073 if v.Cluster != nil { 5074 ok := object.Key("cluster") 5075 ok.String(*v.Cluster) 5076 } 5077 5078 if v.Include != nil { 5079 ok := object.Key("include") 5080 if err := awsAwsjson11_serializeDocumentTaskFieldList(v.Include, ok); err != nil { 5081 return err 5082 } 5083 } 5084 5085 if v.Tasks != nil { 5086 ok := object.Key("tasks") 5087 if err := awsAwsjson11_serializeDocumentStringList(v.Tasks, ok); err != nil { 5088 return err 5089 } 5090 } 5091 5092 return nil 5093} 5094 5095func awsAwsjson11_serializeOpDocumentDiscoverPollEndpointInput(v *DiscoverPollEndpointInput, value smithyjson.Value) error { 5096 object := value.Object() 5097 defer object.Close() 5098 5099 if v.Cluster != nil { 5100 ok := object.Key("cluster") 5101 ok.String(*v.Cluster) 5102 } 5103 5104 if v.ContainerInstance != nil { 5105 ok := object.Key("containerInstance") 5106 ok.String(*v.ContainerInstance) 5107 } 5108 5109 return nil 5110} 5111 5112func awsAwsjson11_serializeOpDocumentListAccountSettingsInput(v *ListAccountSettingsInput, value smithyjson.Value) error { 5113 object := value.Object() 5114 defer object.Close() 5115 5116 if v.EffectiveSettings { 5117 ok := object.Key("effectiveSettings") 5118 ok.Boolean(v.EffectiveSettings) 5119 } 5120 5121 if v.MaxResults != 0 { 5122 ok := object.Key("maxResults") 5123 ok.Integer(v.MaxResults) 5124 } 5125 5126 if len(v.Name) > 0 { 5127 ok := object.Key("name") 5128 ok.String(string(v.Name)) 5129 } 5130 5131 if v.NextToken != nil { 5132 ok := object.Key("nextToken") 5133 ok.String(*v.NextToken) 5134 } 5135 5136 if v.PrincipalArn != nil { 5137 ok := object.Key("principalArn") 5138 ok.String(*v.PrincipalArn) 5139 } 5140 5141 if v.Value != nil { 5142 ok := object.Key("value") 5143 ok.String(*v.Value) 5144 } 5145 5146 return nil 5147} 5148 5149func awsAwsjson11_serializeOpDocumentListAttributesInput(v *ListAttributesInput, value smithyjson.Value) error { 5150 object := value.Object() 5151 defer object.Close() 5152 5153 if v.AttributeName != nil { 5154 ok := object.Key("attributeName") 5155 ok.String(*v.AttributeName) 5156 } 5157 5158 if v.AttributeValue != nil { 5159 ok := object.Key("attributeValue") 5160 ok.String(*v.AttributeValue) 5161 } 5162 5163 if v.Cluster != nil { 5164 ok := object.Key("cluster") 5165 ok.String(*v.Cluster) 5166 } 5167 5168 if v.MaxResults != nil { 5169 ok := object.Key("maxResults") 5170 ok.Integer(*v.MaxResults) 5171 } 5172 5173 if v.NextToken != nil { 5174 ok := object.Key("nextToken") 5175 ok.String(*v.NextToken) 5176 } 5177 5178 if len(v.TargetType) > 0 { 5179 ok := object.Key("targetType") 5180 ok.String(string(v.TargetType)) 5181 } 5182 5183 return nil 5184} 5185 5186func awsAwsjson11_serializeOpDocumentListClustersInput(v *ListClustersInput, value smithyjson.Value) error { 5187 object := value.Object() 5188 defer object.Close() 5189 5190 if v.MaxResults != nil { 5191 ok := object.Key("maxResults") 5192 ok.Integer(*v.MaxResults) 5193 } 5194 5195 if v.NextToken != nil { 5196 ok := object.Key("nextToken") 5197 ok.String(*v.NextToken) 5198 } 5199 5200 return nil 5201} 5202 5203func awsAwsjson11_serializeOpDocumentListContainerInstancesInput(v *ListContainerInstancesInput, value smithyjson.Value) error { 5204 object := value.Object() 5205 defer object.Close() 5206 5207 if v.Cluster != nil { 5208 ok := object.Key("cluster") 5209 ok.String(*v.Cluster) 5210 } 5211 5212 if v.Filter != nil { 5213 ok := object.Key("filter") 5214 ok.String(*v.Filter) 5215 } 5216 5217 if v.MaxResults != nil { 5218 ok := object.Key("maxResults") 5219 ok.Integer(*v.MaxResults) 5220 } 5221 5222 if v.NextToken != nil { 5223 ok := object.Key("nextToken") 5224 ok.String(*v.NextToken) 5225 } 5226 5227 if len(v.Status) > 0 { 5228 ok := object.Key("status") 5229 ok.String(string(v.Status)) 5230 } 5231 5232 return nil 5233} 5234 5235func awsAwsjson11_serializeOpDocumentListServicesInput(v *ListServicesInput, value smithyjson.Value) error { 5236 object := value.Object() 5237 defer object.Close() 5238 5239 if v.Cluster != nil { 5240 ok := object.Key("cluster") 5241 ok.String(*v.Cluster) 5242 } 5243 5244 if len(v.LaunchType) > 0 { 5245 ok := object.Key("launchType") 5246 ok.String(string(v.LaunchType)) 5247 } 5248 5249 if v.MaxResults != nil { 5250 ok := object.Key("maxResults") 5251 ok.Integer(*v.MaxResults) 5252 } 5253 5254 if v.NextToken != nil { 5255 ok := object.Key("nextToken") 5256 ok.String(*v.NextToken) 5257 } 5258 5259 if len(v.SchedulingStrategy) > 0 { 5260 ok := object.Key("schedulingStrategy") 5261 ok.String(string(v.SchedulingStrategy)) 5262 } 5263 5264 return nil 5265} 5266 5267func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error { 5268 object := value.Object() 5269 defer object.Close() 5270 5271 if v.ResourceArn != nil { 5272 ok := object.Key("resourceArn") 5273 ok.String(*v.ResourceArn) 5274 } 5275 5276 return nil 5277} 5278 5279func awsAwsjson11_serializeOpDocumentListTaskDefinitionFamiliesInput(v *ListTaskDefinitionFamiliesInput, value smithyjson.Value) error { 5280 object := value.Object() 5281 defer object.Close() 5282 5283 if v.FamilyPrefix != nil { 5284 ok := object.Key("familyPrefix") 5285 ok.String(*v.FamilyPrefix) 5286 } 5287 5288 if v.MaxResults != nil { 5289 ok := object.Key("maxResults") 5290 ok.Integer(*v.MaxResults) 5291 } 5292 5293 if v.NextToken != nil { 5294 ok := object.Key("nextToken") 5295 ok.String(*v.NextToken) 5296 } 5297 5298 if len(v.Status) > 0 { 5299 ok := object.Key("status") 5300 ok.String(string(v.Status)) 5301 } 5302 5303 return nil 5304} 5305 5306func awsAwsjson11_serializeOpDocumentListTaskDefinitionsInput(v *ListTaskDefinitionsInput, value smithyjson.Value) error { 5307 object := value.Object() 5308 defer object.Close() 5309 5310 if v.FamilyPrefix != nil { 5311 ok := object.Key("familyPrefix") 5312 ok.String(*v.FamilyPrefix) 5313 } 5314 5315 if v.MaxResults != nil { 5316 ok := object.Key("maxResults") 5317 ok.Integer(*v.MaxResults) 5318 } 5319 5320 if v.NextToken != nil { 5321 ok := object.Key("nextToken") 5322 ok.String(*v.NextToken) 5323 } 5324 5325 if len(v.Sort) > 0 { 5326 ok := object.Key("sort") 5327 ok.String(string(v.Sort)) 5328 } 5329 5330 if len(v.Status) > 0 { 5331 ok := object.Key("status") 5332 ok.String(string(v.Status)) 5333 } 5334 5335 return nil 5336} 5337 5338func awsAwsjson11_serializeOpDocumentListTasksInput(v *ListTasksInput, value smithyjson.Value) error { 5339 object := value.Object() 5340 defer object.Close() 5341 5342 if v.Cluster != nil { 5343 ok := object.Key("cluster") 5344 ok.String(*v.Cluster) 5345 } 5346 5347 if v.ContainerInstance != nil { 5348 ok := object.Key("containerInstance") 5349 ok.String(*v.ContainerInstance) 5350 } 5351 5352 if len(v.DesiredStatus) > 0 { 5353 ok := object.Key("desiredStatus") 5354 ok.String(string(v.DesiredStatus)) 5355 } 5356 5357 if v.Family != nil { 5358 ok := object.Key("family") 5359 ok.String(*v.Family) 5360 } 5361 5362 if len(v.LaunchType) > 0 { 5363 ok := object.Key("launchType") 5364 ok.String(string(v.LaunchType)) 5365 } 5366 5367 if v.MaxResults != nil { 5368 ok := object.Key("maxResults") 5369 ok.Integer(*v.MaxResults) 5370 } 5371 5372 if v.NextToken != nil { 5373 ok := object.Key("nextToken") 5374 ok.String(*v.NextToken) 5375 } 5376 5377 if v.ServiceName != nil { 5378 ok := object.Key("serviceName") 5379 ok.String(*v.ServiceName) 5380 } 5381 5382 if v.StartedBy != nil { 5383 ok := object.Key("startedBy") 5384 ok.String(*v.StartedBy) 5385 } 5386 5387 return nil 5388} 5389 5390func awsAwsjson11_serializeOpDocumentPutAccountSettingDefaultInput(v *PutAccountSettingDefaultInput, value smithyjson.Value) error { 5391 object := value.Object() 5392 defer object.Close() 5393 5394 if len(v.Name) > 0 { 5395 ok := object.Key("name") 5396 ok.String(string(v.Name)) 5397 } 5398 5399 if v.Value != nil { 5400 ok := object.Key("value") 5401 ok.String(*v.Value) 5402 } 5403 5404 return nil 5405} 5406 5407func awsAwsjson11_serializeOpDocumentPutAccountSettingInput(v *PutAccountSettingInput, value smithyjson.Value) error { 5408 object := value.Object() 5409 defer object.Close() 5410 5411 if len(v.Name) > 0 { 5412 ok := object.Key("name") 5413 ok.String(string(v.Name)) 5414 } 5415 5416 if v.PrincipalArn != nil { 5417 ok := object.Key("principalArn") 5418 ok.String(*v.PrincipalArn) 5419 } 5420 5421 if v.Value != nil { 5422 ok := object.Key("value") 5423 ok.String(*v.Value) 5424 } 5425 5426 return nil 5427} 5428 5429func awsAwsjson11_serializeOpDocumentPutAttributesInput(v *PutAttributesInput, value smithyjson.Value) error { 5430 object := value.Object() 5431 defer object.Close() 5432 5433 if v.Attributes != nil { 5434 ok := object.Key("attributes") 5435 if err := awsAwsjson11_serializeDocumentAttributes(v.Attributes, ok); err != nil { 5436 return err 5437 } 5438 } 5439 5440 if v.Cluster != nil { 5441 ok := object.Key("cluster") 5442 ok.String(*v.Cluster) 5443 } 5444 5445 return nil 5446} 5447 5448func awsAwsjson11_serializeOpDocumentPutClusterCapacityProvidersInput(v *PutClusterCapacityProvidersInput, value smithyjson.Value) error { 5449 object := value.Object() 5450 defer object.Close() 5451 5452 if v.CapacityProviders != nil { 5453 ok := object.Key("capacityProviders") 5454 if err := awsAwsjson11_serializeDocumentStringList(v.CapacityProviders, ok); err != nil { 5455 return err 5456 } 5457 } 5458 5459 if v.Cluster != nil { 5460 ok := object.Key("cluster") 5461 ok.String(*v.Cluster) 5462 } 5463 5464 if v.DefaultCapacityProviderStrategy != nil { 5465 ok := object.Key("defaultCapacityProviderStrategy") 5466 if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.DefaultCapacityProviderStrategy, ok); err != nil { 5467 return err 5468 } 5469 } 5470 5471 return nil 5472} 5473 5474func awsAwsjson11_serializeOpDocumentRegisterContainerInstanceInput(v *RegisterContainerInstanceInput, value smithyjson.Value) error { 5475 object := value.Object() 5476 defer object.Close() 5477 5478 if v.Attributes != nil { 5479 ok := object.Key("attributes") 5480 if err := awsAwsjson11_serializeDocumentAttributes(v.Attributes, ok); err != nil { 5481 return err 5482 } 5483 } 5484 5485 if v.Cluster != nil { 5486 ok := object.Key("cluster") 5487 ok.String(*v.Cluster) 5488 } 5489 5490 if v.ContainerInstanceArn != nil { 5491 ok := object.Key("containerInstanceArn") 5492 ok.String(*v.ContainerInstanceArn) 5493 } 5494 5495 if v.InstanceIdentityDocument != nil { 5496 ok := object.Key("instanceIdentityDocument") 5497 ok.String(*v.InstanceIdentityDocument) 5498 } 5499 5500 if v.InstanceIdentityDocumentSignature != nil { 5501 ok := object.Key("instanceIdentityDocumentSignature") 5502 ok.String(*v.InstanceIdentityDocumentSignature) 5503 } 5504 5505 if v.PlatformDevices != nil { 5506 ok := object.Key("platformDevices") 5507 if err := awsAwsjson11_serializeDocumentPlatformDevices(v.PlatformDevices, ok); err != nil { 5508 return err 5509 } 5510 } 5511 5512 if v.Tags != nil { 5513 ok := object.Key("tags") 5514 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 5515 return err 5516 } 5517 } 5518 5519 if v.TotalResources != nil { 5520 ok := object.Key("totalResources") 5521 if err := awsAwsjson11_serializeDocumentResources(v.TotalResources, ok); err != nil { 5522 return err 5523 } 5524 } 5525 5526 if v.VersionInfo != nil { 5527 ok := object.Key("versionInfo") 5528 if err := awsAwsjson11_serializeDocumentVersionInfo(v.VersionInfo, ok); err != nil { 5529 return err 5530 } 5531 } 5532 5533 return nil 5534} 5535 5536func awsAwsjson11_serializeOpDocumentRegisterTaskDefinitionInput(v *RegisterTaskDefinitionInput, value smithyjson.Value) error { 5537 object := value.Object() 5538 defer object.Close() 5539 5540 if v.ContainerDefinitions != nil { 5541 ok := object.Key("containerDefinitions") 5542 if err := awsAwsjson11_serializeDocumentContainerDefinitions(v.ContainerDefinitions, ok); err != nil { 5543 return err 5544 } 5545 } 5546 5547 if v.Cpu != nil { 5548 ok := object.Key("cpu") 5549 ok.String(*v.Cpu) 5550 } 5551 5552 if v.ExecutionRoleArn != nil { 5553 ok := object.Key("executionRoleArn") 5554 ok.String(*v.ExecutionRoleArn) 5555 } 5556 5557 if v.Family != nil { 5558 ok := object.Key("family") 5559 ok.String(*v.Family) 5560 } 5561 5562 if v.InferenceAccelerators != nil { 5563 ok := object.Key("inferenceAccelerators") 5564 if err := awsAwsjson11_serializeDocumentInferenceAccelerators(v.InferenceAccelerators, ok); err != nil { 5565 return err 5566 } 5567 } 5568 5569 if len(v.IpcMode) > 0 { 5570 ok := object.Key("ipcMode") 5571 ok.String(string(v.IpcMode)) 5572 } 5573 5574 if v.Memory != nil { 5575 ok := object.Key("memory") 5576 ok.String(*v.Memory) 5577 } 5578 5579 if len(v.NetworkMode) > 0 { 5580 ok := object.Key("networkMode") 5581 ok.String(string(v.NetworkMode)) 5582 } 5583 5584 if len(v.PidMode) > 0 { 5585 ok := object.Key("pidMode") 5586 ok.String(string(v.PidMode)) 5587 } 5588 5589 if v.PlacementConstraints != nil { 5590 ok := object.Key("placementConstraints") 5591 if err := awsAwsjson11_serializeDocumentTaskDefinitionPlacementConstraints(v.PlacementConstraints, ok); err != nil { 5592 return err 5593 } 5594 } 5595 5596 if v.ProxyConfiguration != nil { 5597 ok := object.Key("proxyConfiguration") 5598 if err := awsAwsjson11_serializeDocumentProxyConfiguration(v.ProxyConfiguration, ok); err != nil { 5599 return err 5600 } 5601 } 5602 5603 if v.RequiresCompatibilities != nil { 5604 ok := object.Key("requiresCompatibilities") 5605 if err := awsAwsjson11_serializeDocumentCompatibilityList(v.RequiresCompatibilities, ok); err != nil { 5606 return err 5607 } 5608 } 5609 5610 if v.Tags != nil { 5611 ok := object.Key("tags") 5612 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 5613 return err 5614 } 5615 } 5616 5617 if v.TaskRoleArn != nil { 5618 ok := object.Key("taskRoleArn") 5619 ok.String(*v.TaskRoleArn) 5620 } 5621 5622 if v.Volumes != nil { 5623 ok := object.Key("volumes") 5624 if err := awsAwsjson11_serializeDocumentVolumeList(v.Volumes, ok); err != nil { 5625 return err 5626 } 5627 } 5628 5629 return nil 5630} 5631 5632func awsAwsjson11_serializeOpDocumentRunTaskInput(v *RunTaskInput, value smithyjson.Value) error { 5633 object := value.Object() 5634 defer object.Close() 5635 5636 if v.CapacityProviderStrategy != nil { 5637 ok := object.Key("capacityProviderStrategy") 5638 if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil { 5639 return err 5640 } 5641 } 5642 5643 if v.Cluster != nil { 5644 ok := object.Key("cluster") 5645 ok.String(*v.Cluster) 5646 } 5647 5648 if v.Count != nil { 5649 ok := object.Key("count") 5650 ok.Integer(*v.Count) 5651 } 5652 5653 if v.EnableECSManagedTags { 5654 ok := object.Key("enableECSManagedTags") 5655 ok.Boolean(v.EnableECSManagedTags) 5656 } 5657 5658 if v.Group != nil { 5659 ok := object.Key("group") 5660 ok.String(*v.Group) 5661 } 5662 5663 if len(v.LaunchType) > 0 { 5664 ok := object.Key("launchType") 5665 ok.String(string(v.LaunchType)) 5666 } 5667 5668 if v.NetworkConfiguration != nil { 5669 ok := object.Key("networkConfiguration") 5670 if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil { 5671 return err 5672 } 5673 } 5674 5675 if v.Overrides != nil { 5676 ok := object.Key("overrides") 5677 if err := awsAwsjson11_serializeDocumentTaskOverride(v.Overrides, ok); err != nil { 5678 return err 5679 } 5680 } 5681 5682 if v.PlacementConstraints != nil { 5683 ok := object.Key("placementConstraints") 5684 if err := awsAwsjson11_serializeDocumentPlacementConstraints(v.PlacementConstraints, ok); err != nil { 5685 return err 5686 } 5687 } 5688 5689 if v.PlacementStrategy != nil { 5690 ok := object.Key("placementStrategy") 5691 if err := awsAwsjson11_serializeDocumentPlacementStrategies(v.PlacementStrategy, ok); err != nil { 5692 return err 5693 } 5694 } 5695 5696 if v.PlatformVersion != nil { 5697 ok := object.Key("platformVersion") 5698 ok.String(*v.PlatformVersion) 5699 } 5700 5701 if len(v.PropagateTags) > 0 { 5702 ok := object.Key("propagateTags") 5703 ok.String(string(v.PropagateTags)) 5704 } 5705 5706 if v.ReferenceId != nil { 5707 ok := object.Key("referenceId") 5708 ok.String(*v.ReferenceId) 5709 } 5710 5711 if v.StartedBy != nil { 5712 ok := object.Key("startedBy") 5713 ok.String(*v.StartedBy) 5714 } 5715 5716 if v.Tags != nil { 5717 ok := object.Key("tags") 5718 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 5719 return err 5720 } 5721 } 5722 5723 if v.TaskDefinition != nil { 5724 ok := object.Key("taskDefinition") 5725 ok.String(*v.TaskDefinition) 5726 } 5727 5728 return nil 5729} 5730 5731func awsAwsjson11_serializeOpDocumentStartTaskInput(v *StartTaskInput, value smithyjson.Value) error { 5732 object := value.Object() 5733 defer object.Close() 5734 5735 if v.Cluster != nil { 5736 ok := object.Key("cluster") 5737 ok.String(*v.Cluster) 5738 } 5739 5740 if v.ContainerInstances != nil { 5741 ok := object.Key("containerInstances") 5742 if err := awsAwsjson11_serializeDocumentStringList(v.ContainerInstances, ok); err != nil { 5743 return err 5744 } 5745 } 5746 5747 if v.EnableECSManagedTags { 5748 ok := object.Key("enableECSManagedTags") 5749 ok.Boolean(v.EnableECSManagedTags) 5750 } 5751 5752 if v.Group != nil { 5753 ok := object.Key("group") 5754 ok.String(*v.Group) 5755 } 5756 5757 if v.NetworkConfiguration != nil { 5758 ok := object.Key("networkConfiguration") 5759 if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil { 5760 return err 5761 } 5762 } 5763 5764 if v.Overrides != nil { 5765 ok := object.Key("overrides") 5766 if err := awsAwsjson11_serializeDocumentTaskOverride(v.Overrides, ok); err != nil { 5767 return err 5768 } 5769 } 5770 5771 if len(v.PropagateTags) > 0 { 5772 ok := object.Key("propagateTags") 5773 ok.String(string(v.PropagateTags)) 5774 } 5775 5776 if v.ReferenceId != nil { 5777 ok := object.Key("referenceId") 5778 ok.String(*v.ReferenceId) 5779 } 5780 5781 if v.StartedBy != nil { 5782 ok := object.Key("startedBy") 5783 ok.String(*v.StartedBy) 5784 } 5785 5786 if v.Tags != nil { 5787 ok := object.Key("tags") 5788 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 5789 return err 5790 } 5791 } 5792 5793 if v.TaskDefinition != nil { 5794 ok := object.Key("taskDefinition") 5795 ok.String(*v.TaskDefinition) 5796 } 5797 5798 return nil 5799} 5800 5801func awsAwsjson11_serializeOpDocumentStopTaskInput(v *StopTaskInput, value smithyjson.Value) error { 5802 object := value.Object() 5803 defer object.Close() 5804 5805 if v.Cluster != nil { 5806 ok := object.Key("cluster") 5807 ok.String(*v.Cluster) 5808 } 5809 5810 if v.Reason != nil { 5811 ok := object.Key("reason") 5812 ok.String(*v.Reason) 5813 } 5814 5815 if v.Task != nil { 5816 ok := object.Key("task") 5817 ok.String(*v.Task) 5818 } 5819 5820 return nil 5821} 5822 5823func awsAwsjson11_serializeOpDocumentSubmitAttachmentStateChangesInput(v *SubmitAttachmentStateChangesInput, value smithyjson.Value) error { 5824 object := value.Object() 5825 defer object.Close() 5826 5827 if v.Attachments != nil { 5828 ok := object.Key("attachments") 5829 if err := awsAwsjson11_serializeDocumentAttachmentStateChanges(v.Attachments, ok); err != nil { 5830 return err 5831 } 5832 } 5833 5834 if v.Cluster != nil { 5835 ok := object.Key("cluster") 5836 ok.String(*v.Cluster) 5837 } 5838 5839 return nil 5840} 5841 5842func awsAwsjson11_serializeOpDocumentSubmitContainerStateChangeInput(v *SubmitContainerStateChangeInput, value smithyjson.Value) error { 5843 object := value.Object() 5844 defer object.Close() 5845 5846 if v.Cluster != nil { 5847 ok := object.Key("cluster") 5848 ok.String(*v.Cluster) 5849 } 5850 5851 if v.ContainerName != nil { 5852 ok := object.Key("containerName") 5853 ok.String(*v.ContainerName) 5854 } 5855 5856 if v.ExitCode != nil { 5857 ok := object.Key("exitCode") 5858 ok.Integer(*v.ExitCode) 5859 } 5860 5861 if v.NetworkBindings != nil { 5862 ok := object.Key("networkBindings") 5863 if err := awsAwsjson11_serializeDocumentNetworkBindings(v.NetworkBindings, ok); err != nil { 5864 return err 5865 } 5866 } 5867 5868 if v.Reason != nil { 5869 ok := object.Key("reason") 5870 ok.String(*v.Reason) 5871 } 5872 5873 if v.RuntimeId != nil { 5874 ok := object.Key("runtimeId") 5875 ok.String(*v.RuntimeId) 5876 } 5877 5878 if v.Status != nil { 5879 ok := object.Key("status") 5880 ok.String(*v.Status) 5881 } 5882 5883 if v.Task != nil { 5884 ok := object.Key("task") 5885 ok.String(*v.Task) 5886 } 5887 5888 return nil 5889} 5890 5891func awsAwsjson11_serializeOpDocumentSubmitTaskStateChangeInput(v *SubmitTaskStateChangeInput, value smithyjson.Value) error { 5892 object := value.Object() 5893 defer object.Close() 5894 5895 if v.Attachments != nil { 5896 ok := object.Key("attachments") 5897 if err := awsAwsjson11_serializeDocumentAttachmentStateChanges(v.Attachments, ok); err != nil { 5898 return err 5899 } 5900 } 5901 5902 if v.Cluster != nil { 5903 ok := object.Key("cluster") 5904 ok.String(*v.Cluster) 5905 } 5906 5907 if v.Containers != nil { 5908 ok := object.Key("containers") 5909 if err := awsAwsjson11_serializeDocumentContainerStateChanges(v.Containers, ok); err != nil { 5910 return err 5911 } 5912 } 5913 5914 if v.ExecutionStoppedAt != nil { 5915 ok := object.Key("executionStoppedAt") 5916 ok.Double(smithytime.FormatEpochSeconds(*v.ExecutionStoppedAt)) 5917 } 5918 5919 if v.PullStartedAt != nil { 5920 ok := object.Key("pullStartedAt") 5921 ok.Double(smithytime.FormatEpochSeconds(*v.PullStartedAt)) 5922 } 5923 5924 if v.PullStoppedAt != nil { 5925 ok := object.Key("pullStoppedAt") 5926 ok.Double(smithytime.FormatEpochSeconds(*v.PullStoppedAt)) 5927 } 5928 5929 if v.Reason != nil { 5930 ok := object.Key("reason") 5931 ok.String(*v.Reason) 5932 } 5933 5934 if v.Status != nil { 5935 ok := object.Key("status") 5936 ok.String(*v.Status) 5937 } 5938 5939 if v.Task != nil { 5940 ok := object.Key("task") 5941 ok.String(*v.Task) 5942 } 5943 5944 return nil 5945} 5946 5947func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 5948 object := value.Object() 5949 defer object.Close() 5950 5951 if v.ResourceArn != nil { 5952 ok := object.Key("resourceArn") 5953 ok.String(*v.ResourceArn) 5954 } 5955 5956 if v.Tags != nil { 5957 ok := object.Key("tags") 5958 if err := awsAwsjson11_serializeDocumentTags(v.Tags, ok); err != nil { 5959 return err 5960 } 5961 } 5962 5963 return nil 5964} 5965 5966func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error { 5967 object := value.Object() 5968 defer object.Close() 5969 5970 if v.ResourceArn != nil { 5971 ok := object.Key("resourceArn") 5972 ok.String(*v.ResourceArn) 5973 } 5974 5975 if v.TagKeys != nil { 5976 ok := object.Key("tagKeys") 5977 if err := awsAwsjson11_serializeDocumentTagKeys(v.TagKeys, ok); err != nil { 5978 return err 5979 } 5980 } 5981 5982 return nil 5983} 5984 5985func awsAwsjson11_serializeOpDocumentUpdateCapacityProviderInput(v *UpdateCapacityProviderInput, value smithyjson.Value) error { 5986 object := value.Object() 5987 defer object.Close() 5988 5989 if v.AutoScalingGroupProvider != nil { 5990 ok := object.Key("autoScalingGroupProvider") 5991 if err := awsAwsjson11_serializeDocumentAutoScalingGroupProviderUpdate(v.AutoScalingGroupProvider, ok); err != nil { 5992 return err 5993 } 5994 } 5995 5996 if v.Name != nil { 5997 ok := object.Key("name") 5998 ok.String(*v.Name) 5999 } 6000 6001 return nil 6002} 6003 6004func awsAwsjson11_serializeOpDocumentUpdateClusterSettingsInput(v *UpdateClusterSettingsInput, value smithyjson.Value) error { 6005 object := value.Object() 6006 defer object.Close() 6007 6008 if v.Cluster != nil { 6009 ok := object.Key("cluster") 6010 ok.String(*v.Cluster) 6011 } 6012 6013 if v.Settings != nil { 6014 ok := object.Key("settings") 6015 if err := awsAwsjson11_serializeDocumentClusterSettings(v.Settings, ok); err != nil { 6016 return err 6017 } 6018 } 6019 6020 return nil 6021} 6022 6023func awsAwsjson11_serializeOpDocumentUpdateContainerAgentInput(v *UpdateContainerAgentInput, value smithyjson.Value) error { 6024 object := value.Object() 6025 defer object.Close() 6026 6027 if v.Cluster != nil { 6028 ok := object.Key("cluster") 6029 ok.String(*v.Cluster) 6030 } 6031 6032 if v.ContainerInstance != nil { 6033 ok := object.Key("containerInstance") 6034 ok.String(*v.ContainerInstance) 6035 } 6036 6037 return nil 6038} 6039 6040func awsAwsjson11_serializeOpDocumentUpdateContainerInstancesStateInput(v *UpdateContainerInstancesStateInput, value smithyjson.Value) error { 6041 object := value.Object() 6042 defer object.Close() 6043 6044 if v.Cluster != nil { 6045 ok := object.Key("cluster") 6046 ok.String(*v.Cluster) 6047 } 6048 6049 if v.ContainerInstances != nil { 6050 ok := object.Key("containerInstances") 6051 if err := awsAwsjson11_serializeDocumentStringList(v.ContainerInstances, ok); err != nil { 6052 return err 6053 } 6054 } 6055 6056 if len(v.Status) > 0 { 6057 ok := object.Key("status") 6058 ok.String(string(v.Status)) 6059 } 6060 6061 return nil 6062} 6063 6064func awsAwsjson11_serializeOpDocumentUpdateServiceInput(v *UpdateServiceInput, value smithyjson.Value) error { 6065 object := value.Object() 6066 defer object.Close() 6067 6068 if v.CapacityProviderStrategy != nil { 6069 ok := object.Key("capacityProviderStrategy") 6070 if err := awsAwsjson11_serializeDocumentCapacityProviderStrategy(v.CapacityProviderStrategy, ok); err != nil { 6071 return err 6072 } 6073 } 6074 6075 if v.Cluster != nil { 6076 ok := object.Key("cluster") 6077 ok.String(*v.Cluster) 6078 } 6079 6080 if v.DeploymentConfiguration != nil { 6081 ok := object.Key("deploymentConfiguration") 6082 if err := awsAwsjson11_serializeDocumentDeploymentConfiguration(v.DeploymentConfiguration, ok); err != nil { 6083 return err 6084 } 6085 } 6086 6087 if v.DesiredCount != nil { 6088 ok := object.Key("desiredCount") 6089 ok.Integer(*v.DesiredCount) 6090 } 6091 6092 if v.ForceNewDeployment { 6093 ok := object.Key("forceNewDeployment") 6094 ok.Boolean(v.ForceNewDeployment) 6095 } 6096 6097 if v.HealthCheckGracePeriodSeconds != nil { 6098 ok := object.Key("healthCheckGracePeriodSeconds") 6099 ok.Integer(*v.HealthCheckGracePeriodSeconds) 6100 } 6101 6102 if v.NetworkConfiguration != nil { 6103 ok := object.Key("networkConfiguration") 6104 if err := awsAwsjson11_serializeDocumentNetworkConfiguration(v.NetworkConfiguration, ok); err != nil { 6105 return err 6106 } 6107 } 6108 6109 if v.PlacementConstraints != nil { 6110 ok := object.Key("placementConstraints") 6111 if err := awsAwsjson11_serializeDocumentPlacementConstraints(v.PlacementConstraints, ok); err != nil { 6112 return err 6113 } 6114 } 6115 6116 if v.PlacementStrategy != nil { 6117 ok := object.Key("placementStrategy") 6118 if err := awsAwsjson11_serializeDocumentPlacementStrategies(v.PlacementStrategy, ok); err != nil { 6119 return err 6120 } 6121 } 6122 6123 if v.PlatformVersion != nil { 6124 ok := object.Key("platformVersion") 6125 ok.String(*v.PlatformVersion) 6126 } 6127 6128 if v.Service != nil { 6129 ok := object.Key("service") 6130 ok.String(*v.Service) 6131 } 6132 6133 if v.TaskDefinition != nil { 6134 ok := object.Key("taskDefinition") 6135 ok.String(*v.TaskDefinition) 6136 } 6137 6138 return nil 6139} 6140 6141func awsAwsjson11_serializeOpDocumentUpdateServicePrimaryTaskSetInput(v *UpdateServicePrimaryTaskSetInput, value smithyjson.Value) error { 6142 object := value.Object() 6143 defer object.Close() 6144 6145 if v.Cluster != nil { 6146 ok := object.Key("cluster") 6147 ok.String(*v.Cluster) 6148 } 6149 6150 if v.PrimaryTaskSet != nil { 6151 ok := object.Key("primaryTaskSet") 6152 ok.String(*v.PrimaryTaskSet) 6153 } 6154 6155 if v.Service != nil { 6156 ok := object.Key("service") 6157 ok.String(*v.Service) 6158 } 6159 6160 return nil 6161} 6162 6163func awsAwsjson11_serializeOpDocumentUpdateTaskSetInput(v *UpdateTaskSetInput, value smithyjson.Value) error { 6164 object := value.Object() 6165 defer object.Close() 6166 6167 if v.Cluster != nil { 6168 ok := object.Key("cluster") 6169 ok.String(*v.Cluster) 6170 } 6171 6172 if v.Scale != nil { 6173 ok := object.Key("scale") 6174 if err := awsAwsjson11_serializeDocumentScale(v.Scale, ok); err != nil { 6175 return err 6176 } 6177 } 6178 6179 if v.Service != nil { 6180 ok := object.Key("service") 6181 ok.String(*v.Service) 6182 } 6183 6184 if v.TaskSet != nil { 6185 ok := object.Key("taskSet") 6186 ok.String(*v.TaskSet) 6187 } 6188 6189 return nil 6190} 6191