1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package rekognition 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/rekognition/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15 "math" 16) 17 18type awsAwsjson11_serializeOpCompareFaces struct { 19} 20 21func (*awsAwsjson11_serializeOpCompareFaces) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsAwsjson11_serializeOpCompareFaces) 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.(*CompareFacesInput) 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("RekognitionService.CompareFaces") 47 48 jsonEncoder := smithyjson.NewEncoder() 49 if err := awsAwsjson11_serializeOpDocumentCompareFacesInput(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_serializeOpCreateCollection struct { 66} 67 68func (*awsAwsjson11_serializeOpCreateCollection) ID() string { 69 return "OperationSerializer" 70} 71 72func (m *awsAwsjson11_serializeOpCreateCollection) 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.(*CreateCollectionInput) 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("RekognitionService.CreateCollection") 94 95 jsonEncoder := smithyjson.NewEncoder() 96 if err := awsAwsjson11_serializeOpDocumentCreateCollectionInput(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_serializeOpCreateProject struct { 113} 114 115func (*awsAwsjson11_serializeOpCreateProject) ID() string { 116 return "OperationSerializer" 117} 118 119func (m *awsAwsjson11_serializeOpCreateProject) 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.(*CreateProjectInput) 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("RekognitionService.CreateProject") 141 142 jsonEncoder := smithyjson.NewEncoder() 143 if err := awsAwsjson11_serializeOpDocumentCreateProjectInput(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_serializeOpCreateProjectVersion struct { 160} 161 162func (*awsAwsjson11_serializeOpCreateProjectVersion) ID() string { 163 return "OperationSerializer" 164} 165 166func (m *awsAwsjson11_serializeOpCreateProjectVersion) 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.(*CreateProjectVersionInput) 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("RekognitionService.CreateProjectVersion") 188 189 jsonEncoder := smithyjson.NewEncoder() 190 if err := awsAwsjson11_serializeOpDocumentCreateProjectVersionInput(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_serializeOpCreateStreamProcessor struct { 207} 208 209func (*awsAwsjson11_serializeOpCreateStreamProcessor) ID() string { 210 return "OperationSerializer" 211} 212 213func (m *awsAwsjson11_serializeOpCreateStreamProcessor) 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.(*CreateStreamProcessorInput) 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("RekognitionService.CreateStreamProcessor") 235 236 jsonEncoder := smithyjson.NewEncoder() 237 if err := awsAwsjson11_serializeOpDocumentCreateStreamProcessorInput(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_serializeOpDeleteCollection struct { 254} 255 256func (*awsAwsjson11_serializeOpDeleteCollection) ID() string { 257 return "OperationSerializer" 258} 259 260func (m *awsAwsjson11_serializeOpDeleteCollection) 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.(*DeleteCollectionInput) 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("RekognitionService.DeleteCollection") 282 283 jsonEncoder := smithyjson.NewEncoder() 284 if err := awsAwsjson11_serializeOpDocumentDeleteCollectionInput(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_serializeOpDeleteFaces struct { 301} 302 303func (*awsAwsjson11_serializeOpDeleteFaces) ID() string { 304 return "OperationSerializer" 305} 306 307func (m *awsAwsjson11_serializeOpDeleteFaces) 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.(*DeleteFacesInput) 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("RekognitionService.DeleteFaces") 329 330 jsonEncoder := smithyjson.NewEncoder() 331 if err := awsAwsjson11_serializeOpDocumentDeleteFacesInput(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_serializeOpDeleteProject struct { 348} 349 350func (*awsAwsjson11_serializeOpDeleteProject) ID() string { 351 return "OperationSerializer" 352} 353 354func (m *awsAwsjson11_serializeOpDeleteProject) 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.(*DeleteProjectInput) 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("RekognitionService.DeleteProject") 376 377 jsonEncoder := smithyjson.NewEncoder() 378 if err := awsAwsjson11_serializeOpDocumentDeleteProjectInput(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_serializeOpDeleteProjectVersion struct { 395} 396 397func (*awsAwsjson11_serializeOpDeleteProjectVersion) ID() string { 398 return "OperationSerializer" 399} 400 401func (m *awsAwsjson11_serializeOpDeleteProjectVersion) 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.(*DeleteProjectVersionInput) 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("RekognitionService.DeleteProjectVersion") 423 424 jsonEncoder := smithyjson.NewEncoder() 425 if err := awsAwsjson11_serializeOpDocumentDeleteProjectVersionInput(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_serializeOpDeleteStreamProcessor struct { 442} 443 444func (*awsAwsjson11_serializeOpDeleteStreamProcessor) ID() string { 445 return "OperationSerializer" 446} 447 448func (m *awsAwsjson11_serializeOpDeleteStreamProcessor) 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.(*DeleteStreamProcessorInput) 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("RekognitionService.DeleteStreamProcessor") 470 471 jsonEncoder := smithyjson.NewEncoder() 472 if err := awsAwsjson11_serializeOpDocumentDeleteStreamProcessorInput(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_serializeOpDescribeCollection struct { 489} 490 491func (*awsAwsjson11_serializeOpDescribeCollection) ID() string { 492 return "OperationSerializer" 493} 494 495func (m *awsAwsjson11_serializeOpDescribeCollection) 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.(*DescribeCollectionInput) 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("RekognitionService.DescribeCollection") 517 518 jsonEncoder := smithyjson.NewEncoder() 519 if err := awsAwsjson11_serializeOpDocumentDescribeCollectionInput(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_serializeOpDescribeProjects struct { 536} 537 538func (*awsAwsjson11_serializeOpDescribeProjects) ID() string { 539 return "OperationSerializer" 540} 541 542func (m *awsAwsjson11_serializeOpDescribeProjects) 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.(*DescribeProjectsInput) 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("RekognitionService.DescribeProjects") 564 565 jsonEncoder := smithyjson.NewEncoder() 566 if err := awsAwsjson11_serializeOpDocumentDescribeProjectsInput(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_serializeOpDescribeProjectVersions struct { 583} 584 585func (*awsAwsjson11_serializeOpDescribeProjectVersions) ID() string { 586 return "OperationSerializer" 587} 588 589func (m *awsAwsjson11_serializeOpDescribeProjectVersions) 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.(*DescribeProjectVersionsInput) 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("RekognitionService.DescribeProjectVersions") 611 612 jsonEncoder := smithyjson.NewEncoder() 613 if err := awsAwsjson11_serializeOpDocumentDescribeProjectVersionsInput(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_serializeOpDescribeStreamProcessor struct { 630} 631 632func (*awsAwsjson11_serializeOpDescribeStreamProcessor) ID() string { 633 return "OperationSerializer" 634} 635 636func (m *awsAwsjson11_serializeOpDescribeStreamProcessor) 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.(*DescribeStreamProcessorInput) 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("RekognitionService.DescribeStreamProcessor") 658 659 jsonEncoder := smithyjson.NewEncoder() 660 if err := awsAwsjson11_serializeOpDocumentDescribeStreamProcessorInput(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_serializeOpDetectCustomLabels struct { 677} 678 679func (*awsAwsjson11_serializeOpDetectCustomLabels) ID() string { 680 return "OperationSerializer" 681} 682 683func (m *awsAwsjson11_serializeOpDetectCustomLabels) 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.(*DetectCustomLabelsInput) 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("RekognitionService.DetectCustomLabels") 705 706 jsonEncoder := smithyjson.NewEncoder() 707 if err := awsAwsjson11_serializeOpDocumentDetectCustomLabelsInput(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_serializeOpDetectFaces struct { 724} 725 726func (*awsAwsjson11_serializeOpDetectFaces) ID() string { 727 return "OperationSerializer" 728} 729 730func (m *awsAwsjson11_serializeOpDetectFaces) 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.(*DetectFacesInput) 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("RekognitionService.DetectFaces") 752 753 jsonEncoder := smithyjson.NewEncoder() 754 if err := awsAwsjson11_serializeOpDocumentDetectFacesInput(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_serializeOpDetectLabels struct { 771} 772 773func (*awsAwsjson11_serializeOpDetectLabels) ID() string { 774 return "OperationSerializer" 775} 776 777func (m *awsAwsjson11_serializeOpDetectLabels) 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.(*DetectLabelsInput) 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("RekognitionService.DetectLabels") 799 800 jsonEncoder := smithyjson.NewEncoder() 801 if err := awsAwsjson11_serializeOpDocumentDetectLabelsInput(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_serializeOpDetectModerationLabels struct { 818} 819 820func (*awsAwsjson11_serializeOpDetectModerationLabels) ID() string { 821 return "OperationSerializer" 822} 823 824func (m *awsAwsjson11_serializeOpDetectModerationLabels) 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.(*DetectModerationLabelsInput) 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("RekognitionService.DetectModerationLabels") 846 847 jsonEncoder := smithyjson.NewEncoder() 848 if err := awsAwsjson11_serializeOpDocumentDetectModerationLabelsInput(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_serializeOpDetectProtectiveEquipment struct { 865} 866 867func (*awsAwsjson11_serializeOpDetectProtectiveEquipment) ID() string { 868 return "OperationSerializer" 869} 870 871func (m *awsAwsjson11_serializeOpDetectProtectiveEquipment) 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.(*DetectProtectiveEquipmentInput) 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("RekognitionService.DetectProtectiveEquipment") 893 894 jsonEncoder := smithyjson.NewEncoder() 895 if err := awsAwsjson11_serializeOpDocumentDetectProtectiveEquipmentInput(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_serializeOpDetectText struct { 912} 913 914func (*awsAwsjson11_serializeOpDetectText) ID() string { 915 return "OperationSerializer" 916} 917 918func (m *awsAwsjson11_serializeOpDetectText) 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.(*DetectTextInput) 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("RekognitionService.DetectText") 940 941 jsonEncoder := smithyjson.NewEncoder() 942 if err := awsAwsjson11_serializeOpDocumentDetectTextInput(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_serializeOpGetCelebrityInfo struct { 959} 960 961func (*awsAwsjson11_serializeOpGetCelebrityInfo) ID() string { 962 return "OperationSerializer" 963} 964 965func (m *awsAwsjson11_serializeOpGetCelebrityInfo) 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.(*GetCelebrityInfoInput) 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("RekognitionService.GetCelebrityInfo") 987 988 jsonEncoder := smithyjson.NewEncoder() 989 if err := awsAwsjson11_serializeOpDocumentGetCelebrityInfoInput(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_serializeOpGetCelebrityRecognition struct { 1006} 1007 1008func (*awsAwsjson11_serializeOpGetCelebrityRecognition) ID() string { 1009 return "OperationSerializer" 1010} 1011 1012func (m *awsAwsjson11_serializeOpGetCelebrityRecognition) 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.(*GetCelebrityRecognitionInput) 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("RekognitionService.GetCelebrityRecognition") 1034 1035 jsonEncoder := smithyjson.NewEncoder() 1036 if err := awsAwsjson11_serializeOpDocumentGetCelebrityRecognitionInput(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_serializeOpGetContentModeration struct { 1053} 1054 1055func (*awsAwsjson11_serializeOpGetContentModeration) ID() string { 1056 return "OperationSerializer" 1057} 1058 1059func (m *awsAwsjson11_serializeOpGetContentModeration) 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.(*GetContentModerationInput) 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("RekognitionService.GetContentModeration") 1081 1082 jsonEncoder := smithyjson.NewEncoder() 1083 if err := awsAwsjson11_serializeOpDocumentGetContentModerationInput(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_serializeOpGetFaceDetection struct { 1100} 1101 1102func (*awsAwsjson11_serializeOpGetFaceDetection) ID() string { 1103 return "OperationSerializer" 1104} 1105 1106func (m *awsAwsjson11_serializeOpGetFaceDetection) 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.(*GetFaceDetectionInput) 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("RekognitionService.GetFaceDetection") 1128 1129 jsonEncoder := smithyjson.NewEncoder() 1130 if err := awsAwsjson11_serializeOpDocumentGetFaceDetectionInput(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_serializeOpGetFaceSearch struct { 1147} 1148 1149func (*awsAwsjson11_serializeOpGetFaceSearch) ID() string { 1150 return "OperationSerializer" 1151} 1152 1153func (m *awsAwsjson11_serializeOpGetFaceSearch) 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.(*GetFaceSearchInput) 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("RekognitionService.GetFaceSearch") 1175 1176 jsonEncoder := smithyjson.NewEncoder() 1177 if err := awsAwsjson11_serializeOpDocumentGetFaceSearchInput(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_serializeOpGetLabelDetection struct { 1194} 1195 1196func (*awsAwsjson11_serializeOpGetLabelDetection) ID() string { 1197 return "OperationSerializer" 1198} 1199 1200func (m *awsAwsjson11_serializeOpGetLabelDetection) 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.(*GetLabelDetectionInput) 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("RekognitionService.GetLabelDetection") 1222 1223 jsonEncoder := smithyjson.NewEncoder() 1224 if err := awsAwsjson11_serializeOpDocumentGetLabelDetectionInput(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_serializeOpGetPersonTracking struct { 1241} 1242 1243func (*awsAwsjson11_serializeOpGetPersonTracking) ID() string { 1244 return "OperationSerializer" 1245} 1246 1247func (m *awsAwsjson11_serializeOpGetPersonTracking) 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.(*GetPersonTrackingInput) 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("RekognitionService.GetPersonTracking") 1269 1270 jsonEncoder := smithyjson.NewEncoder() 1271 if err := awsAwsjson11_serializeOpDocumentGetPersonTrackingInput(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_serializeOpGetSegmentDetection struct { 1288} 1289 1290func (*awsAwsjson11_serializeOpGetSegmentDetection) ID() string { 1291 return "OperationSerializer" 1292} 1293 1294func (m *awsAwsjson11_serializeOpGetSegmentDetection) 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.(*GetSegmentDetectionInput) 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("RekognitionService.GetSegmentDetection") 1316 1317 jsonEncoder := smithyjson.NewEncoder() 1318 if err := awsAwsjson11_serializeOpDocumentGetSegmentDetectionInput(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_serializeOpGetTextDetection struct { 1335} 1336 1337func (*awsAwsjson11_serializeOpGetTextDetection) ID() string { 1338 return "OperationSerializer" 1339} 1340 1341func (m *awsAwsjson11_serializeOpGetTextDetection) 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.(*GetTextDetectionInput) 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("RekognitionService.GetTextDetection") 1363 1364 jsonEncoder := smithyjson.NewEncoder() 1365 if err := awsAwsjson11_serializeOpDocumentGetTextDetectionInput(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_serializeOpIndexFaces struct { 1382} 1383 1384func (*awsAwsjson11_serializeOpIndexFaces) ID() string { 1385 return "OperationSerializer" 1386} 1387 1388func (m *awsAwsjson11_serializeOpIndexFaces) 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.(*IndexFacesInput) 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("RekognitionService.IndexFaces") 1410 1411 jsonEncoder := smithyjson.NewEncoder() 1412 if err := awsAwsjson11_serializeOpDocumentIndexFacesInput(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_serializeOpListCollections struct { 1429} 1430 1431func (*awsAwsjson11_serializeOpListCollections) ID() string { 1432 return "OperationSerializer" 1433} 1434 1435func (m *awsAwsjson11_serializeOpListCollections) 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.(*ListCollectionsInput) 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("RekognitionService.ListCollections") 1457 1458 jsonEncoder := smithyjson.NewEncoder() 1459 if err := awsAwsjson11_serializeOpDocumentListCollectionsInput(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_serializeOpListFaces struct { 1476} 1477 1478func (*awsAwsjson11_serializeOpListFaces) ID() string { 1479 return "OperationSerializer" 1480} 1481 1482func (m *awsAwsjson11_serializeOpListFaces) 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.(*ListFacesInput) 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("RekognitionService.ListFaces") 1504 1505 jsonEncoder := smithyjson.NewEncoder() 1506 if err := awsAwsjson11_serializeOpDocumentListFacesInput(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_serializeOpListStreamProcessors struct { 1523} 1524 1525func (*awsAwsjson11_serializeOpListStreamProcessors) ID() string { 1526 return "OperationSerializer" 1527} 1528 1529func (m *awsAwsjson11_serializeOpListStreamProcessors) 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.(*ListStreamProcessorsInput) 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("RekognitionService.ListStreamProcessors") 1551 1552 jsonEncoder := smithyjson.NewEncoder() 1553 if err := awsAwsjson11_serializeOpDocumentListStreamProcessorsInput(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_serializeOpListTagsForResource struct { 1570} 1571 1572func (*awsAwsjson11_serializeOpListTagsForResource) ID() string { 1573 return "OperationSerializer" 1574} 1575 1576func (m *awsAwsjson11_serializeOpListTagsForResource) 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.(*ListTagsForResourceInput) 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("RekognitionService.ListTagsForResource") 1598 1599 jsonEncoder := smithyjson.NewEncoder() 1600 if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(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_serializeOpRecognizeCelebrities struct { 1617} 1618 1619func (*awsAwsjson11_serializeOpRecognizeCelebrities) ID() string { 1620 return "OperationSerializer" 1621} 1622 1623func (m *awsAwsjson11_serializeOpRecognizeCelebrities) 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.(*RecognizeCelebritiesInput) 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("RekognitionService.RecognizeCelebrities") 1645 1646 jsonEncoder := smithyjson.NewEncoder() 1647 if err := awsAwsjson11_serializeOpDocumentRecognizeCelebritiesInput(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_serializeOpSearchFaces struct { 1664} 1665 1666func (*awsAwsjson11_serializeOpSearchFaces) ID() string { 1667 return "OperationSerializer" 1668} 1669 1670func (m *awsAwsjson11_serializeOpSearchFaces) 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.(*SearchFacesInput) 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("RekognitionService.SearchFaces") 1692 1693 jsonEncoder := smithyjson.NewEncoder() 1694 if err := awsAwsjson11_serializeOpDocumentSearchFacesInput(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_serializeOpSearchFacesByImage struct { 1711} 1712 1713func (*awsAwsjson11_serializeOpSearchFacesByImage) ID() string { 1714 return "OperationSerializer" 1715} 1716 1717func (m *awsAwsjson11_serializeOpSearchFacesByImage) 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.(*SearchFacesByImageInput) 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("RekognitionService.SearchFacesByImage") 1739 1740 jsonEncoder := smithyjson.NewEncoder() 1741 if err := awsAwsjson11_serializeOpDocumentSearchFacesByImageInput(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_serializeOpStartCelebrityRecognition struct { 1758} 1759 1760func (*awsAwsjson11_serializeOpStartCelebrityRecognition) ID() string { 1761 return "OperationSerializer" 1762} 1763 1764func (m *awsAwsjson11_serializeOpStartCelebrityRecognition) 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.(*StartCelebrityRecognitionInput) 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("RekognitionService.StartCelebrityRecognition") 1786 1787 jsonEncoder := smithyjson.NewEncoder() 1788 if err := awsAwsjson11_serializeOpDocumentStartCelebrityRecognitionInput(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_serializeOpStartContentModeration struct { 1805} 1806 1807func (*awsAwsjson11_serializeOpStartContentModeration) ID() string { 1808 return "OperationSerializer" 1809} 1810 1811func (m *awsAwsjson11_serializeOpStartContentModeration) 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.(*StartContentModerationInput) 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("RekognitionService.StartContentModeration") 1833 1834 jsonEncoder := smithyjson.NewEncoder() 1835 if err := awsAwsjson11_serializeOpDocumentStartContentModerationInput(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_serializeOpStartFaceDetection struct { 1852} 1853 1854func (*awsAwsjson11_serializeOpStartFaceDetection) ID() string { 1855 return "OperationSerializer" 1856} 1857 1858func (m *awsAwsjson11_serializeOpStartFaceDetection) 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.(*StartFaceDetectionInput) 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("RekognitionService.StartFaceDetection") 1880 1881 jsonEncoder := smithyjson.NewEncoder() 1882 if err := awsAwsjson11_serializeOpDocumentStartFaceDetectionInput(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_serializeOpStartFaceSearch struct { 1899} 1900 1901func (*awsAwsjson11_serializeOpStartFaceSearch) ID() string { 1902 return "OperationSerializer" 1903} 1904 1905func (m *awsAwsjson11_serializeOpStartFaceSearch) 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.(*StartFaceSearchInput) 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("RekognitionService.StartFaceSearch") 1927 1928 jsonEncoder := smithyjson.NewEncoder() 1929 if err := awsAwsjson11_serializeOpDocumentStartFaceSearchInput(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_serializeOpStartLabelDetection struct { 1946} 1947 1948func (*awsAwsjson11_serializeOpStartLabelDetection) ID() string { 1949 return "OperationSerializer" 1950} 1951 1952func (m *awsAwsjson11_serializeOpStartLabelDetection) 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.(*StartLabelDetectionInput) 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("RekognitionService.StartLabelDetection") 1974 1975 jsonEncoder := smithyjson.NewEncoder() 1976 if err := awsAwsjson11_serializeOpDocumentStartLabelDetectionInput(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_serializeOpStartPersonTracking struct { 1993} 1994 1995func (*awsAwsjson11_serializeOpStartPersonTracking) ID() string { 1996 return "OperationSerializer" 1997} 1998 1999func (m *awsAwsjson11_serializeOpStartPersonTracking) 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.(*StartPersonTrackingInput) 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("RekognitionService.StartPersonTracking") 2021 2022 jsonEncoder := smithyjson.NewEncoder() 2023 if err := awsAwsjson11_serializeOpDocumentStartPersonTrackingInput(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_serializeOpStartProjectVersion struct { 2040} 2041 2042func (*awsAwsjson11_serializeOpStartProjectVersion) ID() string { 2043 return "OperationSerializer" 2044} 2045 2046func (m *awsAwsjson11_serializeOpStartProjectVersion) 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.(*StartProjectVersionInput) 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("RekognitionService.StartProjectVersion") 2068 2069 jsonEncoder := smithyjson.NewEncoder() 2070 if err := awsAwsjson11_serializeOpDocumentStartProjectVersionInput(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_serializeOpStartSegmentDetection struct { 2087} 2088 2089func (*awsAwsjson11_serializeOpStartSegmentDetection) ID() string { 2090 return "OperationSerializer" 2091} 2092 2093func (m *awsAwsjson11_serializeOpStartSegmentDetection) 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.(*StartSegmentDetectionInput) 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("RekognitionService.StartSegmentDetection") 2115 2116 jsonEncoder := smithyjson.NewEncoder() 2117 if err := awsAwsjson11_serializeOpDocumentStartSegmentDetectionInput(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_serializeOpStartStreamProcessor struct { 2134} 2135 2136func (*awsAwsjson11_serializeOpStartStreamProcessor) ID() string { 2137 return "OperationSerializer" 2138} 2139 2140func (m *awsAwsjson11_serializeOpStartStreamProcessor) 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.(*StartStreamProcessorInput) 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("RekognitionService.StartStreamProcessor") 2162 2163 jsonEncoder := smithyjson.NewEncoder() 2164 if err := awsAwsjson11_serializeOpDocumentStartStreamProcessorInput(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_serializeOpStartTextDetection struct { 2181} 2182 2183func (*awsAwsjson11_serializeOpStartTextDetection) ID() string { 2184 return "OperationSerializer" 2185} 2186 2187func (m *awsAwsjson11_serializeOpStartTextDetection) 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.(*StartTextDetectionInput) 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("RekognitionService.StartTextDetection") 2209 2210 jsonEncoder := smithyjson.NewEncoder() 2211 if err := awsAwsjson11_serializeOpDocumentStartTextDetectionInput(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_serializeOpStopProjectVersion struct { 2228} 2229 2230func (*awsAwsjson11_serializeOpStopProjectVersion) ID() string { 2231 return "OperationSerializer" 2232} 2233 2234func (m *awsAwsjson11_serializeOpStopProjectVersion) 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.(*StopProjectVersionInput) 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("RekognitionService.StopProjectVersion") 2256 2257 jsonEncoder := smithyjson.NewEncoder() 2258 if err := awsAwsjson11_serializeOpDocumentStopProjectVersionInput(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_serializeOpStopStreamProcessor struct { 2275} 2276 2277func (*awsAwsjson11_serializeOpStopStreamProcessor) ID() string { 2278 return "OperationSerializer" 2279} 2280 2281func (m *awsAwsjson11_serializeOpStopStreamProcessor) 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.(*StopStreamProcessorInput) 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("RekognitionService.StopStreamProcessor") 2303 2304 jsonEncoder := smithyjson.NewEncoder() 2305 if err := awsAwsjson11_serializeOpDocumentStopStreamProcessorInput(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_serializeOpTagResource struct { 2322} 2323 2324func (*awsAwsjson11_serializeOpTagResource) ID() string { 2325 return "OperationSerializer" 2326} 2327 2328func (m *awsAwsjson11_serializeOpTagResource) 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.(*TagResourceInput) 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("RekognitionService.TagResource") 2350 2351 jsonEncoder := smithyjson.NewEncoder() 2352 if err := awsAwsjson11_serializeOpDocumentTagResourceInput(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} 2367 2368type awsAwsjson11_serializeOpUntagResource struct { 2369} 2370 2371func (*awsAwsjson11_serializeOpUntagResource) ID() string { 2372 return "OperationSerializer" 2373} 2374 2375func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2376 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2377) { 2378 request, ok := in.Request.(*smithyhttp.Request) 2379 if !ok { 2380 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2381 } 2382 2383 input, ok := in.Parameters.(*UntagResourceInput) 2384 _ = input 2385 if !ok { 2386 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2387 } 2388 2389 request.Request.URL.Path = "/" 2390 request.Request.Method = "POST" 2391 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2392 if err != nil { 2393 return out, metadata, &smithy.SerializationError{Err: err} 2394 } 2395 httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1") 2396 httpBindingEncoder.SetHeader("X-Amz-Target").String("RekognitionService.UntagResource") 2397 2398 jsonEncoder := smithyjson.NewEncoder() 2399 if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil { 2400 return out, metadata, &smithy.SerializationError{Err: err} 2401 } 2402 2403 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2404 return out, metadata, &smithy.SerializationError{Err: err} 2405 } 2406 2407 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2408 return out, metadata, &smithy.SerializationError{Err: err} 2409 } 2410 in.Request = request 2411 2412 return next.HandleSerialize(ctx, in) 2413} 2414func awsAwsjson11_serializeDocumentAsset(v *types.Asset, value smithyjson.Value) error { 2415 object := value.Object() 2416 defer object.Close() 2417 2418 if v.GroundTruthManifest != nil { 2419 ok := object.Key("GroundTruthManifest") 2420 if err := awsAwsjson11_serializeDocumentGroundTruthManifest(v.GroundTruthManifest, ok); err != nil { 2421 return err 2422 } 2423 } 2424 2425 return nil 2426} 2427 2428func awsAwsjson11_serializeDocumentAssets(v []types.Asset, value smithyjson.Value) error { 2429 array := value.Array() 2430 defer array.Close() 2431 2432 for i := range v { 2433 av := array.Value() 2434 if err := awsAwsjson11_serializeDocumentAsset(&v[i], av); err != nil { 2435 return err 2436 } 2437 } 2438 return nil 2439} 2440 2441func awsAwsjson11_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error { 2442 array := value.Array() 2443 defer array.Close() 2444 2445 for i := range v { 2446 av := array.Value() 2447 av.String(string(v[i])) 2448 } 2449 return nil 2450} 2451 2452func awsAwsjson11_serializeDocumentBlackFrame(v *types.BlackFrame, value smithyjson.Value) error { 2453 object := value.Object() 2454 defer object.Close() 2455 2456 if v.MaxPixelThreshold != nil { 2457 ok := object.Key("MaxPixelThreshold") 2458 switch { 2459 case math.IsNaN(float64(*v.MaxPixelThreshold)): 2460 ok.String("NaN") 2461 2462 case math.IsInf(float64(*v.MaxPixelThreshold), 1): 2463 ok.String("Infinity") 2464 2465 case math.IsInf(float64(*v.MaxPixelThreshold), -1): 2466 ok.String("-Infinity") 2467 2468 default: 2469 ok.Float(*v.MaxPixelThreshold) 2470 2471 } 2472 } 2473 2474 if v.MinCoveragePercentage != nil { 2475 ok := object.Key("MinCoveragePercentage") 2476 switch { 2477 case math.IsNaN(float64(*v.MinCoveragePercentage)): 2478 ok.String("NaN") 2479 2480 case math.IsInf(float64(*v.MinCoveragePercentage), 1): 2481 ok.String("Infinity") 2482 2483 case math.IsInf(float64(*v.MinCoveragePercentage), -1): 2484 ok.String("-Infinity") 2485 2486 default: 2487 ok.Float(*v.MinCoveragePercentage) 2488 2489 } 2490 } 2491 2492 return nil 2493} 2494 2495func awsAwsjson11_serializeDocumentBoundingBox(v *types.BoundingBox, value smithyjson.Value) error { 2496 object := value.Object() 2497 defer object.Close() 2498 2499 if v.Height != nil { 2500 ok := object.Key("Height") 2501 switch { 2502 case math.IsNaN(float64(*v.Height)): 2503 ok.String("NaN") 2504 2505 case math.IsInf(float64(*v.Height), 1): 2506 ok.String("Infinity") 2507 2508 case math.IsInf(float64(*v.Height), -1): 2509 ok.String("-Infinity") 2510 2511 default: 2512 ok.Float(*v.Height) 2513 2514 } 2515 } 2516 2517 if v.Left != nil { 2518 ok := object.Key("Left") 2519 switch { 2520 case math.IsNaN(float64(*v.Left)): 2521 ok.String("NaN") 2522 2523 case math.IsInf(float64(*v.Left), 1): 2524 ok.String("Infinity") 2525 2526 case math.IsInf(float64(*v.Left), -1): 2527 ok.String("-Infinity") 2528 2529 default: 2530 ok.Float(*v.Left) 2531 2532 } 2533 } 2534 2535 if v.Top != nil { 2536 ok := object.Key("Top") 2537 switch { 2538 case math.IsNaN(float64(*v.Top)): 2539 ok.String("NaN") 2540 2541 case math.IsInf(float64(*v.Top), 1): 2542 ok.String("Infinity") 2543 2544 case math.IsInf(float64(*v.Top), -1): 2545 ok.String("-Infinity") 2546 2547 default: 2548 ok.Float(*v.Top) 2549 2550 } 2551 } 2552 2553 if v.Width != nil { 2554 ok := object.Key("Width") 2555 switch { 2556 case math.IsNaN(float64(*v.Width)): 2557 ok.String("NaN") 2558 2559 case math.IsInf(float64(*v.Width), 1): 2560 ok.String("Infinity") 2561 2562 case math.IsInf(float64(*v.Width), -1): 2563 ok.String("-Infinity") 2564 2565 default: 2566 ok.Float(*v.Width) 2567 2568 } 2569 } 2570 2571 return nil 2572} 2573 2574func awsAwsjson11_serializeDocumentContentClassifiers(v []types.ContentClassifier, value smithyjson.Value) error { 2575 array := value.Array() 2576 defer array.Close() 2577 2578 for i := range v { 2579 av := array.Value() 2580 av.String(string(v[i])) 2581 } 2582 return nil 2583} 2584 2585func awsAwsjson11_serializeDocumentDetectionFilter(v *types.DetectionFilter, value smithyjson.Value) error { 2586 object := value.Object() 2587 defer object.Close() 2588 2589 if v.MinBoundingBoxHeight != nil { 2590 ok := object.Key("MinBoundingBoxHeight") 2591 switch { 2592 case math.IsNaN(float64(*v.MinBoundingBoxHeight)): 2593 ok.String("NaN") 2594 2595 case math.IsInf(float64(*v.MinBoundingBoxHeight), 1): 2596 ok.String("Infinity") 2597 2598 case math.IsInf(float64(*v.MinBoundingBoxHeight), -1): 2599 ok.String("-Infinity") 2600 2601 default: 2602 ok.Float(*v.MinBoundingBoxHeight) 2603 2604 } 2605 } 2606 2607 if v.MinBoundingBoxWidth != nil { 2608 ok := object.Key("MinBoundingBoxWidth") 2609 switch { 2610 case math.IsNaN(float64(*v.MinBoundingBoxWidth)): 2611 ok.String("NaN") 2612 2613 case math.IsInf(float64(*v.MinBoundingBoxWidth), 1): 2614 ok.String("Infinity") 2615 2616 case math.IsInf(float64(*v.MinBoundingBoxWidth), -1): 2617 ok.String("-Infinity") 2618 2619 default: 2620 ok.Float(*v.MinBoundingBoxWidth) 2621 2622 } 2623 } 2624 2625 if v.MinConfidence != nil { 2626 ok := object.Key("MinConfidence") 2627 switch { 2628 case math.IsNaN(float64(*v.MinConfidence)): 2629 ok.String("NaN") 2630 2631 case math.IsInf(float64(*v.MinConfidence), 1): 2632 ok.String("Infinity") 2633 2634 case math.IsInf(float64(*v.MinConfidence), -1): 2635 ok.String("-Infinity") 2636 2637 default: 2638 ok.Float(*v.MinConfidence) 2639 2640 } 2641 } 2642 2643 return nil 2644} 2645 2646func awsAwsjson11_serializeDocumentDetectTextFilters(v *types.DetectTextFilters, value smithyjson.Value) error { 2647 object := value.Object() 2648 defer object.Close() 2649 2650 if v.RegionsOfInterest != nil { 2651 ok := object.Key("RegionsOfInterest") 2652 if err := awsAwsjson11_serializeDocumentRegionsOfInterest(v.RegionsOfInterest, ok); err != nil { 2653 return err 2654 } 2655 } 2656 2657 if v.WordFilter != nil { 2658 ok := object.Key("WordFilter") 2659 if err := awsAwsjson11_serializeDocumentDetectionFilter(v.WordFilter, ok); err != nil { 2660 return err 2661 } 2662 } 2663 2664 return nil 2665} 2666 2667func awsAwsjson11_serializeDocumentFaceIdList(v []string, value smithyjson.Value) error { 2668 array := value.Array() 2669 defer array.Close() 2670 2671 for i := range v { 2672 av := array.Value() 2673 av.String(v[i]) 2674 } 2675 return nil 2676} 2677 2678func awsAwsjson11_serializeDocumentFaceSearchSettings(v *types.FaceSearchSettings, value smithyjson.Value) error { 2679 object := value.Object() 2680 defer object.Close() 2681 2682 if v.CollectionId != nil { 2683 ok := object.Key("CollectionId") 2684 ok.String(*v.CollectionId) 2685 } 2686 2687 if v.FaceMatchThreshold != nil { 2688 ok := object.Key("FaceMatchThreshold") 2689 switch { 2690 case math.IsNaN(float64(*v.FaceMatchThreshold)): 2691 ok.String("NaN") 2692 2693 case math.IsInf(float64(*v.FaceMatchThreshold), 1): 2694 ok.String("Infinity") 2695 2696 case math.IsInf(float64(*v.FaceMatchThreshold), -1): 2697 ok.String("-Infinity") 2698 2699 default: 2700 ok.Float(*v.FaceMatchThreshold) 2701 2702 } 2703 } 2704 2705 return nil 2706} 2707 2708func awsAwsjson11_serializeDocumentGroundTruthManifest(v *types.GroundTruthManifest, value smithyjson.Value) error { 2709 object := value.Object() 2710 defer object.Close() 2711 2712 if v.S3Object != nil { 2713 ok := object.Key("S3Object") 2714 if err := awsAwsjson11_serializeDocumentS3Object(v.S3Object, ok); err != nil { 2715 return err 2716 } 2717 } 2718 2719 return nil 2720} 2721 2722func awsAwsjson11_serializeDocumentHumanLoopConfig(v *types.HumanLoopConfig, value smithyjson.Value) error { 2723 object := value.Object() 2724 defer object.Close() 2725 2726 if v.DataAttributes != nil { 2727 ok := object.Key("DataAttributes") 2728 if err := awsAwsjson11_serializeDocumentHumanLoopDataAttributes(v.DataAttributes, ok); err != nil { 2729 return err 2730 } 2731 } 2732 2733 if v.FlowDefinitionArn != nil { 2734 ok := object.Key("FlowDefinitionArn") 2735 ok.String(*v.FlowDefinitionArn) 2736 } 2737 2738 if v.HumanLoopName != nil { 2739 ok := object.Key("HumanLoopName") 2740 ok.String(*v.HumanLoopName) 2741 } 2742 2743 return nil 2744} 2745 2746func awsAwsjson11_serializeDocumentHumanLoopDataAttributes(v *types.HumanLoopDataAttributes, value smithyjson.Value) error { 2747 object := value.Object() 2748 defer object.Close() 2749 2750 if v.ContentClassifiers != nil { 2751 ok := object.Key("ContentClassifiers") 2752 if err := awsAwsjson11_serializeDocumentContentClassifiers(v.ContentClassifiers, ok); err != nil { 2753 return err 2754 } 2755 } 2756 2757 return nil 2758} 2759 2760func awsAwsjson11_serializeDocumentImage(v *types.Image, value smithyjson.Value) error { 2761 object := value.Object() 2762 defer object.Close() 2763 2764 if v.Bytes != nil { 2765 ok := object.Key("Bytes") 2766 ok.Base64EncodeBytes(v.Bytes) 2767 } 2768 2769 if v.S3Object != nil { 2770 ok := object.Key("S3Object") 2771 if err := awsAwsjson11_serializeDocumentS3Object(v.S3Object, ok); err != nil { 2772 return err 2773 } 2774 } 2775 2776 return nil 2777} 2778 2779func awsAwsjson11_serializeDocumentKinesisDataStream(v *types.KinesisDataStream, value smithyjson.Value) error { 2780 object := value.Object() 2781 defer object.Close() 2782 2783 if v.Arn != nil { 2784 ok := object.Key("Arn") 2785 ok.String(*v.Arn) 2786 } 2787 2788 return nil 2789} 2790 2791func awsAwsjson11_serializeDocumentKinesisVideoStream(v *types.KinesisVideoStream, value smithyjson.Value) error { 2792 object := value.Object() 2793 defer object.Close() 2794 2795 if v.Arn != nil { 2796 ok := object.Key("Arn") 2797 ok.String(*v.Arn) 2798 } 2799 2800 return nil 2801} 2802 2803func awsAwsjson11_serializeDocumentNotificationChannel(v *types.NotificationChannel, value smithyjson.Value) error { 2804 object := value.Object() 2805 defer object.Close() 2806 2807 if v.RoleArn != nil { 2808 ok := object.Key("RoleArn") 2809 ok.String(*v.RoleArn) 2810 } 2811 2812 if v.SNSTopicArn != nil { 2813 ok := object.Key("SNSTopicArn") 2814 ok.String(*v.SNSTopicArn) 2815 } 2816 2817 return nil 2818} 2819 2820func awsAwsjson11_serializeDocumentOutputConfig(v *types.OutputConfig, value smithyjson.Value) error { 2821 object := value.Object() 2822 defer object.Close() 2823 2824 if v.S3Bucket != nil { 2825 ok := object.Key("S3Bucket") 2826 ok.String(*v.S3Bucket) 2827 } 2828 2829 if v.S3KeyPrefix != nil { 2830 ok := object.Key("S3KeyPrefix") 2831 ok.String(*v.S3KeyPrefix) 2832 } 2833 2834 return nil 2835} 2836 2837func awsAwsjson11_serializeDocumentProtectiveEquipmentSummarizationAttributes(v *types.ProtectiveEquipmentSummarizationAttributes, value smithyjson.Value) error { 2838 object := value.Object() 2839 defer object.Close() 2840 2841 if v.MinConfidence != nil { 2842 ok := object.Key("MinConfidence") 2843 switch { 2844 case math.IsNaN(float64(*v.MinConfidence)): 2845 ok.String("NaN") 2846 2847 case math.IsInf(float64(*v.MinConfidence), 1): 2848 ok.String("Infinity") 2849 2850 case math.IsInf(float64(*v.MinConfidence), -1): 2851 ok.String("-Infinity") 2852 2853 default: 2854 ok.Float(*v.MinConfidence) 2855 2856 } 2857 } 2858 2859 if v.RequiredEquipmentTypes != nil { 2860 ok := object.Key("RequiredEquipmentTypes") 2861 if err := awsAwsjson11_serializeDocumentProtectiveEquipmentTypes(v.RequiredEquipmentTypes, ok); err != nil { 2862 return err 2863 } 2864 } 2865 2866 return nil 2867} 2868 2869func awsAwsjson11_serializeDocumentProtectiveEquipmentTypes(v []types.ProtectiveEquipmentType, value smithyjson.Value) error { 2870 array := value.Array() 2871 defer array.Close() 2872 2873 for i := range v { 2874 av := array.Value() 2875 av.String(string(v[i])) 2876 } 2877 return nil 2878} 2879 2880func awsAwsjson11_serializeDocumentRegionOfInterest(v *types.RegionOfInterest, value smithyjson.Value) error { 2881 object := value.Object() 2882 defer object.Close() 2883 2884 if v.BoundingBox != nil { 2885 ok := object.Key("BoundingBox") 2886 if err := awsAwsjson11_serializeDocumentBoundingBox(v.BoundingBox, ok); err != nil { 2887 return err 2888 } 2889 } 2890 2891 return nil 2892} 2893 2894func awsAwsjson11_serializeDocumentRegionsOfInterest(v []types.RegionOfInterest, value smithyjson.Value) error { 2895 array := value.Array() 2896 defer array.Close() 2897 2898 for i := range v { 2899 av := array.Value() 2900 if err := awsAwsjson11_serializeDocumentRegionOfInterest(&v[i], av); err != nil { 2901 return err 2902 } 2903 } 2904 return nil 2905} 2906 2907func awsAwsjson11_serializeDocumentS3Object(v *types.S3Object, value smithyjson.Value) error { 2908 object := value.Object() 2909 defer object.Close() 2910 2911 if v.Bucket != nil { 2912 ok := object.Key("Bucket") 2913 ok.String(*v.Bucket) 2914 } 2915 2916 if v.Name != nil { 2917 ok := object.Key("Name") 2918 ok.String(*v.Name) 2919 } 2920 2921 if v.Version != nil { 2922 ok := object.Key("Version") 2923 ok.String(*v.Version) 2924 } 2925 2926 return nil 2927} 2928 2929func awsAwsjson11_serializeDocumentSegmentTypes(v []types.SegmentType, value smithyjson.Value) error { 2930 array := value.Array() 2931 defer array.Close() 2932 2933 for i := range v { 2934 av := array.Value() 2935 av.String(string(v[i])) 2936 } 2937 return nil 2938} 2939 2940func awsAwsjson11_serializeDocumentStartSegmentDetectionFilters(v *types.StartSegmentDetectionFilters, value smithyjson.Value) error { 2941 object := value.Object() 2942 defer object.Close() 2943 2944 if v.ShotFilter != nil { 2945 ok := object.Key("ShotFilter") 2946 if err := awsAwsjson11_serializeDocumentStartShotDetectionFilter(v.ShotFilter, ok); err != nil { 2947 return err 2948 } 2949 } 2950 2951 if v.TechnicalCueFilter != nil { 2952 ok := object.Key("TechnicalCueFilter") 2953 if err := awsAwsjson11_serializeDocumentStartTechnicalCueDetectionFilter(v.TechnicalCueFilter, ok); err != nil { 2954 return err 2955 } 2956 } 2957 2958 return nil 2959} 2960 2961func awsAwsjson11_serializeDocumentStartShotDetectionFilter(v *types.StartShotDetectionFilter, value smithyjson.Value) error { 2962 object := value.Object() 2963 defer object.Close() 2964 2965 if v.MinSegmentConfidence != nil { 2966 ok := object.Key("MinSegmentConfidence") 2967 switch { 2968 case math.IsNaN(float64(*v.MinSegmentConfidence)): 2969 ok.String("NaN") 2970 2971 case math.IsInf(float64(*v.MinSegmentConfidence), 1): 2972 ok.String("Infinity") 2973 2974 case math.IsInf(float64(*v.MinSegmentConfidence), -1): 2975 ok.String("-Infinity") 2976 2977 default: 2978 ok.Float(*v.MinSegmentConfidence) 2979 2980 } 2981 } 2982 2983 return nil 2984} 2985 2986func awsAwsjson11_serializeDocumentStartTechnicalCueDetectionFilter(v *types.StartTechnicalCueDetectionFilter, value smithyjson.Value) error { 2987 object := value.Object() 2988 defer object.Close() 2989 2990 if v.BlackFrame != nil { 2991 ok := object.Key("BlackFrame") 2992 if err := awsAwsjson11_serializeDocumentBlackFrame(v.BlackFrame, ok); err != nil { 2993 return err 2994 } 2995 } 2996 2997 if v.MinSegmentConfidence != nil { 2998 ok := object.Key("MinSegmentConfidence") 2999 switch { 3000 case math.IsNaN(float64(*v.MinSegmentConfidence)): 3001 ok.String("NaN") 3002 3003 case math.IsInf(float64(*v.MinSegmentConfidence), 1): 3004 ok.String("Infinity") 3005 3006 case math.IsInf(float64(*v.MinSegmentConfidence), -1): 3007 ok.String("-Infinity") 3008 3009 default: 3010 ok.Float(*v.MinSegmentConfidence) 3011 3012 } 3013 } 3014 3015 return nil 3016} 3017 3018func awsAwsjson11_serializeDocumentStartTextDetectionFilters(v *types.StartTextDetectionFilters, value smithyjson.Value) error { 3019 object := value.Object() 3020 defer object.Close() 3021 3022 if v.RegionsOfInterest != nil { 3023 ok := object.Key("RegionsOfInterest") 3024 if err := awsAwsjson11_serializeDocumentRegionsOfInterest(v.RegionsOfInterest, ok); err != nil { 3025 return err 3026 } 3027 } 3028 3029 if v.WordFilter != nil { 3030 ok := object.Key("WordFilter") 3031 if err := awsAwsjson11_serializeDocumentDetectionFilter(v.WordFilter, ok); err != nil { 3032 return err 3033 } 3034 } 3035 3036 return nil 3037} 3038 3039func awsAwsjson11_serializeDocumentStreamProcessorInput(v *types.StreamProcessorInput, value smithyjson.Value) error { 3040 object := value.Object() 3041 defer object.Close() 3042 3043 if v.KinesisVideoStream != nil { 3044 ok := object.Key("KinesisVideoStream") 3045 if err := awsAwsjson11_serializeDocumentKinesisVideoStream(v.KinesisVideoStream, ok); err != nil { 3046 return err 3047 } 3048 } 3049 3050 return nil 3051} 3052 3053func awsAwsjson11_serializeDocumentStreamProcessorOutput(v *types.StreamProcessorOutput, value smithyjson.Value) error { 3054 object := value.Object() 3055 defer object.Close() 3056 3057 if v.KinesisDataStream != nil { 3058 ok := object.Key("KinesisDataStream") 3059 if err := awsAwsjson11_serializeDocumentKinesisDataStream(v.KinesisDataStream, ok); err != nil { 3060 return err 3061 } 3062 } 3063 3064 return nil 3065} 3066 3067func awsAwsjson11_serializeDocumentStreamProcessorSettings(v *types.StreamProcessorSettings, value smithyjson.Value) error { 3068 object := value.Object() 3069 defer object.Close() 3070 3071 if v.FaceSearch != nil { 3072 ok := object.Key("FaceSearch") 3073 if err := awsAwsjson11_serializeDocumentFaceSearchSettings(v.FaceSearch, ok); err != nil { 3074 return err 3075 } 3076 } 3077 3078 return nil 3079} 3080 3081func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error { 3082 array := value.Array() 3083 defer array.Close() 3084 3085 for i := range v { 3086 av := array.Value() 3087 av.String(v[i]) 3088 } 3089 return nil 3090} 3091 3092func awsAwsjson11_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 3093 object := value.Object() 3094 defer object.Close() 3095 3096 for key := range v { 3097 om := object.Key(key) 3098 om.String(v[key]) 3099 } 3100 return nil 3101} 3102 3103func awsAwsjson11_serializeDocumentTestingData(v *types.TestingData, value smithyjson.Value) error { 3104 object := value.Object() 3105 defer object.Close() 3106 3107 if v.Assets != nil { 3108 ok := object.Key("Assets") 3109 if err := awsAwsjson11_serializeDocumentAssets(v.Assets, ok); err != nil { 3110 return err 3111 } 3112 } 3113 3114 if v.AutoCreate { 3115 ok := object.Key("AutoCreate") 3116 ok.Boolean(v.AutoCreate) 3117 } 3118 3119 return nil 3120} 3121 3122func awsAwsjson11_serializeDocumentTrainingData(v *types.TrainingData, value smithyjson.Value) error { 3123 object := value.Object() 3124 defer object.Close() 3125 3126 if v.Assets != nil { 3127 ok := object.Key("Assets") 3128 if err := awsAwsjson11_serializeDocumentAssets(v.Assets, ok); err != nil { 3129 return err 3130 } 3131 } 3132 3133 return nil 3134} 3135 3136func awsAwsjson11_serializeDocumentVersionNames(v []string, value smithyjson.Value) error { 3137 array := value.Array() 3138 defer array.Close() 3139 3140 for i := range v { 3141 av := array.Value() 3142 av.String(v[i]) 3143 } 3144 return nil 3145} 3146 3147func awsAwsjson11_serializeDocumentVideo(v *types.Video, value smithyjson.Value) error { 3148 object := value.Object() 3149 defer object.Close() 3150 3151 if v.S3Object != nil { 3152 ok := object.Key("S3Object") 3153 if err := awsAwsjson11_serializeDocumentS3Object(v.S3Object, ok); err != nil { 3154 return err 3155 } 3156 } 3157 3158 return nil 3159} 3160 3161func awsAwsjson11_serializeOpDocumentCompareFacesInput(v *CompareFacesInput, value smithyjson.Value) error { 3162 object := value.Object() 3163 defer object.Close() 3164 3165 if len(v.QualityFilter) > 0 { 3166 ok := object.Key("QualityFilter") 3167 ok.String(string(v.QualityFilter)) 3168 } 3169 3170 if v.SimilarityThreshold != nil { 3171 ok := object.Key("SimilarityThreshold") 3172 switch { 3173 case math.IsNaN(float64(*v.SimilarityThreshold)): 3174 ok.String("NaN") 3175 3176 case math.IsInf(float64(*v.SimilarityThreshold), 1): 3177 ok.String("Infinity") 3178 3179 case math.IsInf(float64(*v.SimilarityThreshold), -1): 3180 ok.String("-Infinity") 3181 3182 default: 3183 ok.Float(*v.SimilarityThreshold) 3184 3185 } 3186 } 3187 3188 if v.SourceImage != nil { 3189 ok := object.Key("SourceImage") 3190 if err := awsAwsjson11_serializeDocumentImage(v.SourceImage, ok); err != nil { 3191 return err 3192 } 3193 } 3194 3195 if v.TargetImage != nil { 3196 ok := object.Key("TargetImage") 3197 if err := awsAwsjson11_serializeDocumentImage(v.TargetImage, ok); err != nil { 3198 return err 3199 } 3200 } 3201 3202 return nil 3203} 3204 3205func awsAwsjson11_serializeOpDocumentCreateCollectionInput(v *CreateCollectionInput, value smithyjson.Value) error { 3206 object := value.Object() 3207 defer object.Close() 3208 3209 if v.CollectionId != nil { 3210 ok := object.Key("CollectionId") 3211 ok.String(*v.CollectionId) 3212 } 3213 3214 if v.Tags != nil { 3215 ok := object.Key("Tags") 3216 if err := awsAwsjson11_serializeDocumentTagMap(v.Tags, ok); err != nil { 3217 return err 3218 } 3219 } 3220 3221 return nil 3222} 3223 3224func awsAwsjson11_serializeOpDocumentCreateProjectInput(v *CreateProjectInput, value smithyjson.Value) error { 3225 object := value.Object() 3226 defer object.Close() 3227 3228 if v.ProjectName != nil { 3229 ok := object.Key("ProjectName") 3230 ok.String(*v.ProjectName) 3231 } 3232 3233 return nil 3234} 3235 3236func awsAwsjson11_serializeOpDocumentCreateProjectVersionInput(v *CreateProjectVersionInput, value smithyjson.Value) error { 3237 object := value.Object() 3238 defer object.Close() 3239 3240 if v.KmsKeyId != nil { 3241 ok := object.Key("KmsKeyId") 3242 ok.String(*v.KmsKeyId) 3243 } 3244 3245 if v.OutputConfig != nil { 3246 ok := object.Key("OutputConfig") 3247 if err := awsAwsjson11_serializeDocumentOutputConfig(v.OutputConfig, ok); err != nil { 3248 return err 3249 } 3250 } 3251 3252 if v.ProjectArn != nil { 3253 ok := object.Key("ProjectArn") 3254 ok.String(*v.ProjectArn) 3255 } 3256 3257 if v.Tags != nil { 3258 ok := object.Key("Tags") 3259 if err := awsAwsjson11_serializeDocumentTagMap(v.Tags, ok); err != nil { 3260 return err 3261 } 3262 } 3263 3264 if v.TestingData != nil { 3265 ok := object.Key("TestingData") 3266 if err := awsAwsjson11_serializeDocumentTestingData(v.TestingData, ok); err != nil { 3267 return err 3268 } 3269 } 3270 3271 if v.TrainingData != nil { 3272 ok := object.Key("TrainingData") 3273 if err := awsAwsjson11_serializeDocumentTrainingData(v.TrainingData, ok); err != nil { 3274 return err 3275 } 3276 } 3277 3278 if v.VersionName != nil { 3279 ok := object.Key("VersionName") 3280 ok.String(*v.VersionName) 3281 } 3282 3283 return nil 3284} 3285 3286func awsAwsjson11_serializeOpDocumentCreateStreamProcessorInput(v *CreateStreamProcessorInput, value smithyjson.Value) error { 3287 object := value.Object() 3288 defer object.Close() 3289 3290 if v.Input != nil { 3291 ok := object.Key("Input") 3292 if err := awsAwsjson11_serializeDocumentStreamProcessorInput(v.Input, ok); err != nil { 3293 return err 3294 } 3295 } 3296 3297 if v.Name != nil { 3298 ok := object.Key("Name") 3299 ok.String(*v.Name) 3300 } 3301 3302 if v.Output != nil { 3303 ok := object.Key("Output") 3304 if err := awsAwsjson11_serializeDocumentStreamProcessorOutput(v.Output, ok); err != nil { 3305 return err 3306 } 3307 } 3308 3309 if v.RoleArn != nil { 3310 ok := object.Key("RoleArn") 3311 ok.String(*v.RoleArn) 3312 } 3313 3314 if v.Settings != nil { 3315 ok := object.Key("Settings") 3316 if err := awsAwsjson11_serializeDocumentStreamProcessorSettings(v.Settings, ok); err != nil { 3317 return err 3318 } 3319 } 3320 3321 if v.Tags != nil { 3322 ok := object.Key("Tags") 3323 if err := awsAwsjson11_serializeDocumentTagMap(v.Tags, ok); err != nil { 3324 return err 3325 } 3326 } 3327 3328 return nil 3329} 3330 3331func awsAwsjson11_serializeOpDocumentDeleteCollectionInput(v *DeleteCollectionInput, value smithyjson.Value) error { 3332 object := value.Object() 3333 defer object.Close() 3334 3335 if v.CollectionId != nil { 3336 ok := object.Key("CollectionId") 3337 ok.String(*v.CollectionId) 3338 } 3339 3340 return nil 3341} 3342 3343func awsAwsjson11_serializeOpDocumentDeleteFacesInput(v *DeleteFacesInput, value smithyjson.Value) error { 3344 object := value.Object() 3345 defer object.Close() 3346 3347 if v.CollectionId != nil { 3348 ok := object.Key("CollectionId") 3349 ok.String(*v.CollectionId) 3350 } 3351 3352 if v.FaceIds != nil { 3353 ok := object.Key("FaceIds") 3354 if err := awsAwsjson11_serializeDocumentFaceIdList(v.FaceIds, ok); err != nil { 3355 return err 3356 } 3357 } 3358 3359 return nil 3360} 3361 3362func awsAwsjson11_serializeOpDocumentDeleteProjectInput(v *DeleteProjectInput, value smithyjson.Value) error { 3363 object := value.Object() 3364 defer object.Close() 3365 3366 if v.ProjectArn != nil { 3367 ok := object.Key("ProjectArn") 3368 ok.String(*v.ProjectArn) 3369 } 3370 3371 return nil 3372} 3373 3374func awsAwsjson11_serializeOpDocumentDeleteProjectVersionInput(v *DeleteProjectVersionInput, value smithyjson.Value) error { 3375 object := value.Object() 3376 defer object.Close() 3377 3378 if v.ProjectVersionArn != nil { 3379 ok := object.Key("ProjectVersionArn") 3380 ok.String(*v.ProjectVersionArn) 3381 } 3382 3383 return nil 3384} 3385 3386func awsAwsjson11_serializeOpDocumentDeleteStreamProcessorInput(v *DeleteStreamProcessorInput, value smithyjson.Value) error { 3387 object := value.Object() 3388 defer object.Close() 3389 3390 if v.Name != nil { 3391 ok := object.Key("Name") 3392 ok.String(*v.Name) 3393 } 3394 3395 return nil 3396} 3397 3398func awsAwsjson11_serializeOpDocumentDescribeCollectionInput(v *DescribeCollectionInput, value smithyjson.Value) error { 3399 object := value.Object() 3400 defer object.Close() 3401 3402 if v.CollectionId != nil { 3403 ok := object.Key("CollectionId") 3404 ok.String(*v.CollectionId) 3405 } 3406 3407 return nil 3408} 3409 3410func awsAwsjson11_serializeOpDocumentDescribeProjectsInput(v *DescribeProjectsInput, value smithyjson.Value) error { 3411 object := value.Object() 3412 defer object.Close() 3413 3414 if v.MaxResults != nil { 3415 ok := object.Key("MaxResults") 3416 ok.Integer(*v.MaxResults) 3417 } 3418 3419 if v.NextToken != nil { 3420 ok := object.Key("NextToken") 3421 ok.String(*v.NextToken) 3422 } 3423 3424 return nil 3425} 3426 3427func awsAwsjson11_serializeOpDocumentDescribeProjectVersionsInput(v *DescribeProjectVersionsInput, value smithyjson.Value) error { 3428 object := value.Object() 3429 defer object.Close() 3430 3431 if v.MaxResults != nil { 3432 ok := object.Key("MaxResults") 3433 ok.Integer(*v.MaxResults) 3434 } 3435 3436 if v.NextToken != nil { 3437 ok := object.Key("NextToken") 3438 ok.String(*v.NextToken) 3439 } 3440 3441 if v.ProjectArn != nil { 3442 ok := object.Key("ProjectArn") 3443 ok.String(*v.ProjectArn) 3444 } 3445 3446 if v.VersionNames != nil { 3447 ok := object.Key("VersionNames") 3448 if err := awsAwsjson11_serializeDocumentVersionNames(v.VersionNames, ok); err != nil { 3449 return err 3450 } 3451 } 3452 3453 return nil 3454} 3455 3456func awsAwsjson11_serializeOpDocumentDescribeStreamProcessorInput(v *DescribeStreamProcessorInput, value smithyjson.Value) error { 3457 object := value.Object() 3458 defer object.Close() 3459 3460 if v.Name != nil { 3461 ok := object.Key("Name") 3462 ok.String(*v.Name) 3463 } 3464 3465 return nil 3466} 3467 3468func awsAwsjson11_serializeOpDocumentDetectCustomLabelsInput(v *DetectCustomLabelsInput, value smithyjson.Value) error { 3469 object := value.Object() 3470 defer object.Close() 3471 3472 if v.Image != nil { 3473 ok := object.Key("Image") 3474 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3475 return err 3476 } 3477 } 3478 3479 if v.MaxResults != nil { 3480 ok := object.Key("MaxResults") 3481 ok.Integer(*v.MaxResults) 3482 } 3483 3484 if v.MinConfidence != nil { 3485 ok := object.Key("MinConfidence") 3486 switch { 3487 case math.IsNaN(float64(*v.MinConfidence)): 3488 ok.String("NaN") 3489 3490 case math.IsInf(float64(*v.MinConfidence), 1): 3491 ok.String("Infinity") 3492 3493 case math.IsInf(float64(*v.MinConfidence), -1): 3494 ok.String("-Infinity") 3495 3496 default: 3497 ok.Float(*v.MinConfidence) 3498 3499 } 3500 } 3501 3502 if v.ProjectVersionArn != nil { 3503 ok := object.Key("ProjectVersionArn") 3504 ok.String(*v.ProjectVersionArn) 3505 } 3506 3507 return nil 3508} 3509 3510func awsAwsjson11_serializeOpDocumentDetectFacesInput(v *DetectFacesInput, value smithyjson.Value) error { 3511 object := value.Object() 3512 defer object.Close() 3513 3514 if v.Attributes != nil { 3515 ok := object.Key("Attributes") 3516 if err := awsAwsjson11_serializeDocumentAttributes(v.Attributes, ok); err != nil { 3517 return err 3518 } 3519 } 3520 3521 if v.Image != nil { 3522 ok := object.Key("Image") 3523 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3524 return err 3525 } 3526 } 3527 3528 return nil 3529} 3530 3531func awsAwsjson11_serializeOpDocumentDetectLabelsInput(v *DetectLabelsInput, value smithyjson.Value) error { 3532 object := value.Object() 3533 defer object.Close() 3534 3535 if v.Image != nil { 3536 ok := object.Key("Image") 3537 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3538 return err 3539 } 3540 } 3541 3542 if v.MaxLabels != nil { 3543 ok := object.Key("MaxLabels") 3544 ok.Integer(*v.MaxLabels) 3545 } 3546 3547 if v.MinConfidence != nil { 3548 ok := object.Key("MinConfidence") 3549 switch { 3550 case math.IsNaN(float64(*v.MinConfidence)): 3551 ok.String("NaN") 3552 3553 case math.IsInf(float64(*v.MinConfidence), 1): 3554 ok.String("Infinity") 3555 3556 case math.IsInf(float64(*v.MinConfidence), -1): 3557 ok.String("-Infinity") 3558 3559 default: 3560 ok.Float(*v.MinConfidence) 3561 3562 } 3563 } 3564 3565 return nil 3566} 3567 3568func awsAwsjson11_serializeOpDocumentDetectModerationLabelsInput(v *DetectModerationLabelsInput, value smithyjson.Value) error { 3569 object := value.Object() 3570 defer object.Close() 3571 3572 if v.HumanLoopConfig != nil { 3573 ok := object.Key("HumanLoopConfig") 3574 if err := awsAwsjson11_serializeDocumentHumanLoopConfig(v.HumanLoopConfig, ok); err != nil { 3575 return err 3576 } 3577 } 3578 3579 if v.Image != nil { 3580 ok := object.Key("Image") 3581 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3582 return err 3583 } 3584 } 3585 3586 if v.MinConfidence != nil { 3587 ok := object.Key("MinConfidence") 3588 switch { 3589 case math.IsNaN(float64(*v.MinConfidence)): 3590 ok.String("NaN") 3591 3592 case math.IsInf(float64(*v.MinConfidence), 1): 3593 ok.String("Infinity") 3594 3595 case math.IsInf(float64(*v.MinConfidence), -1): 3596 ok.String("-Infinity") 3597 3598 default: 3599 ok.Float(*v.MinConfidence) 3600 3601 } 3602 } 3603 3604 return nil 3605} 3606 3607func awsAwsjson11_serializeOpDocumentDetectProtectiveEquipmentInput(v *DetectProtectiveEquipmentInput, value smithyjson.Value) error { 3608 object := value.Object() 3609 defer object.Close() 3610 3611 if v.Image != nil { 3612 ok := object.Key("Image") 3613 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3614 return err 3615 } 3616 } 3617 3618 if v.SummarizationAttributes != nil { 3619 ok := object.Key("SummarizationAttributes") 3620 if err := awsAwsjson11_serializeDocumentProtectiveEquipmentSummarizationAttributes(v.SummarizationAttributes, ok); err != nil { 3621 return err 3622 } 3623 } 3624 3625 return nil 3626} 3627 3628func awsAwsjson11_serializeOpDocumentDetectTextInput(v *DetectTextInput, value smithyjson.Value) error { 3629 object := value.Object() 3630 defer object.Close() 3631 3632 if v.Filters != nil { 3633 ok := object.Key("Filters") 3634 if err := awsAwsjson11_serializeDocumentDetectTextFilters(v.Filters, ok); err != nil { 3635 return err 3636 } 3637 } 3638 3639 if v.Image != nil { 3640 ok := object.Key("Image") 3641 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3642 return err 3643 } 3644 } 3645 3646 return nil 3647} 3648 3649func awsAwsjson11_serializeOpDocumentGetCelebrityInfoInput(v *GetCelebrityInfoInput, value smithyjson.Value) error { 3650 object := value.Object() 3651 defer object.Close() 3652 3653 if v.Id != nil { 3654 ok := object.Key("Id") 3655 ok.String(*v.Id) 3656 } 3657 3658 return nil 3659} 3660 3661func awsAwsjson11_serializeOpDocumentGetCelebrityRecognitionInput(v *GetCelebrityRecognitionInput, value smithyjson.Value) error { 3662 object := value.Object() 3663 defer object.Close() 3664 3665 if v.JobId != nil { 3666 ok := object.Key("JobId") 3667 ok.String(*v.JobId) 3668 } 3669 3670 if v.MaxResults != nil { 3671 ok := object.Key("MaxResults") 3672 ok.Integer(*v.MaxResults) 3673 } 3674 3675 if v.NextToken != nil { 3676 ok := object.Key("NextToken") 3677 ok.String(*v.NextToken) 3678 } 3679 3680 if len(v.SortBy) > 0 { 3681 ok := object.Key("SortBy") 3682 ok.String(string(v.SortBy)) 3683 } 3684 3685 return nil 3686} 3687 3688func awsAwsjson11_serializeOpDocumentGetContentModerationInput(v *GetContentModerationInput, value smithyjson.Value) error { 3689 object := value.Object() 3690 defer object.Close() 3691 3692 if v.JobId != nil { 3693 ok := object.Key("JobId") 3694 ok.String(*v.JobId) 3695 } 3696 3697 if v.MaxResults != nil { 3698 ok := object.Key("MaxResults") 3699 ok.Integer(*v.MaxResults) 3700 } 3701 3702 if v.NextToken != nil { 3703 ok := object.Key("NextToken") 3704 ok.String(*v.NextToken) 3705 } 3706 3707 if len(v.SortBy) > 0 { 3708 ok := object.Key("SortBy") 3709 ok.String(string(v.SortBy)) 3710 } 3711 3712 return nil 3713} 3714 3715func awsAwsjson11_serializeOpDocumentGetFaceDetectionInput(v *GetFaceDetectionInput, value smithyjson.Value) error { 3716 object := value.Object() 3717 defer object.Close() 3718 3719 if v.JobId != nil { 3720 ok := object.Key("JobId") 3721 ok.String(*v.JobId) 3722 } 3723 3724 if v.MaxResults != nil { 3725 ok := object.Key("MaxResults") 3726 ok.Integer(*v.MaxResults) 3727 } 3728 3729 if v.NextToken != nil { 3730 ok := object.Key("NextToken") 3731 ok.String(*v.NextToken) 3732 } 3733 3734 return nil 3735} 3736 3737func awsAwsjson11_serializeOpDocumentGetFaceSearchInput(v *GetFaceSearchInput, value smithyjson.Value) error { 3738 object := value.Object() 3739 defer object.Close() 3740 3741 if v.JobId != nil { 3742 ok := object.Key("JobId") 3743 ok.String(*v.JobId) 3744 } 3745 3746 if v.MaxResults != nil { 3747 ok := object.Key("MaxResults") 3748 ok.Integer(*v.MaxResults) 3749 } 3750 3751 if v.NextToken != nil { 3752 ok := object.Key("NextToken") 3753 ok.String(*v.NextToken) 3754 } 3755 3756 if len(v.SortBy) > 0 { 3757 ok := object.Key("SortBy") 3758 ok.String(string(v.SortBy)) 3759 } 3760 3761 return nil 3762} 3763 3764func awsAwsjson11_serializeOpDocumentGetLabelDetectionInput(v *GetLabelDetectionInput, value smithyjson.Value) error { 3765 object := value.Object() 3766 defer object.Close() 3767 3768 if v.JobId != nil { 3769 ok := object.Key("JobId") 3770 ok.String(*v.JobId) 3771 } 3772 3773 if v.MaxResults != nil { 3774 ok := object.Key("MaxResults") 3775 ok.Integer(*v.MaxResults) 3776 } 3777 3778 if v.NextToken != nil { 3779 ok := object.Key("NextToken") 3780 ok.String(*v.NextToken) 3781 } 3782 3783 if len(v.SortBy) > 0 { 3784 ok := object.Key("SortBy") 3785 ok.String(string(v.SortBy)) 3786 } 3787 3788 return nil 3789} 3790 3791func awsAwsjson11_serializeOpDocumentGetPersonTrackingInput(v *GetPersonTrackingInput, value smithyjson.Value) error { 3792 object := value.Object() 3793 defer object.Close() 3794 3795 if v.JobId != nil { 3796 ok := object.Key("JobId") 3797 ok.String(*v.JobId) 3798 } 3799 3800 if v.MaxResults != nil { 3801 ok := object.Key("MaxResults") 3802 ok.Integer(*v.MaxResults) 3803 } 3804 3805 if v.NextToken != nil { 3806 ok := object.Key("NextToken") 3807 ok.String(*v.NextToken) 3808 } 3809 3810 if len(v.SortBy) > 0 { 3811 ok := object.Key("SortBy") 3812 ok.String(string(v.SortBy)) 3813 } 3814 3815 return nil 3816} 3817 3818func awsAwsjson11_serializeOpDocumentGetSegmentDetectionInput(v *GetSegmentDetectionInput, value smithyjson.Value) error { 3819 object := value.Object() 3820 defer object.Close() 3821 3822 if v.JobId != nil { 3823 ok := object.Key("JobId") 3824 ok.String(*v.JobId) 3825 } 3826 3827 if v.MaxResults != nil { 3828 ok := object.Key("MaxResults") 3829 ok.Integer(*v.MaxResults) 3830 } 3831 3832 if v.NextToken != nil { 3833 ok := object.Key("NextToken") 3834 ok.String(*v.NextToken) 3835 } 3836 3837 return nil 3838} 3839 3840func awsAwsjson11_serializeOpDocumentGetTextDetectionInput(v *GetTextDetectionInput, value smithyjson.Value) error { 3841 object := value.Object() 3842 defer object.Close() 3843 3844 if v.JobId != nil { 3845 ok := object.Key("JobId") 3846 ok.String(*v.JobId) 3847 } 3848 3849 if v.MaxResults != nil { 3850 ok := object.Key("MaxResults") 3851 ok.Integer(*v.MaxResults) 3852 } 3853 3854 if v.NextToken != nil { 3855 ok := object.Key("NextToken") 3856 ok.String(*v.NextToken) 3857 } 3858 3859 return nil 3860} 3861 3862func awsAwsjson11_serializeOpDocumentIndexFacesInput(v *IndexFacesInput, value smithyjson.Value) error { 3863 object := value.Object() 3864 defer object.Close() 3865 3866 if v.CollectionId != nil { 3867 ok := object.Key("CollectionId") 3868 ok.String(*v.CollectionId) 3869 } 3870 3871 if v.DetectionAttributes != nil { 3872 ok := object.Key("DetectionAttributes") 3873 if err := awsAwsjson11_serializeDocumentAttributes(v.DetectionAttributes, ok); err != nil { 3874 return err 3875 } 3876 } 3877 3878 if v.ExternalImageId != nil { 3879 ok := object.Key("ExternalImageId") 3880 ok.String(*v.ExternalImageId) 3881 } 3882 3883 if v.Image != nil { 3884 ok := object.Key("Image") 3885 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3886 return err 3887 } 3888 } 3889 3890 if v.MaxFaces != nil { 3891 ok := object.Key("MaxFaces") 3892 ok.Integer(*v.MaxFaces) 3893 } 3894 3895 if len(v.QualityFilter) > 0 { 3896 ok := object.Key("QualityFilter") 3897 ok.String(string(v.QualityFilter)) 3898 } 3899 3900 return nil 3901} 3902 3903func awsAwsjson11_serializeOpDocumentListCollectionsInput(v *ListCollectionsInput, value smithyjson.Value) error { 3904 object := value.Object() 3905 defer object.Close() 3906 3907 if v.MaxResults != nil { 3908 ok := object.Key("MaxResults") 3909 ok.Integer(*v.MaxResults) 3910 } 3911 3912 if v.NextToken != nil { 3913 ok := object.Key("NextToken") 3914 ok.String(*v.NextToken) 3915 } 3916 3917 return nil 3918} 3919 3920func awsAwsjson11_serializeOpDocumentListFacesInput(v *ListFacesInput, value smithyjson.Value) error { 3921 object := value.Object() 3922 defer object.Close() 3923 3924 if v.CollectionId != nil { 3925 ok := object.Key("CollectionId") 3926 ok.String(*v.CollectionId) 3927 } 3928 3929 if v.MaxResults != nil { 3930 ok := object.Key("MaxResults") 3931 ok.Integer(*v.MaxResults) 3932 } 3933 3934 if v.NextToken != nil { 3935 ok := object.Key("NextToken") 3936 ok.String(*v.NextToken) 3937 } 3938 3939 return nil 3940} 3941 3942func awsAwsjson11_serializeOpDocumentListStreamProcessorsInput(v *ListStreamProcessorsInput, value smithyjson.Value) error { 3943 object := value.Object() 3944 defer object.Close() 3945 3946 if v.MaxResults != nil { 3947 ok := object.Key("MaxResults") 3948 ok.Integer(*v.MaxResults) 3949 } 3950 3951 if v.NextToken != nil { 3952 ok := object.Key("NextToken") 3953 ok.String(*v.NextToken) 3954 } 3955 3956 return nil 3957} 3958 3959func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error { 3960 object := value.Object() 3961 defer object.Close() 3962 3963 if v.ResourceArn != nil { 3964 ok := object.Key("ResourceArn") 3965 ok.String(*v.ResourceArn) 3966 } 3967 3968 return nil 3969} 3970 3971func awsAwsjson11_serializeOpDocumentRecognizeCelebritiesInput(v *RecognizeCelebritiesInput, value smithyjson.Value) error { 3972 object := value.Object() 3973 defer object.Close() 3974 3975 if v.Image != nil { 3976 ok := object.Key("Image") 3977 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 3978 return err 3979 } 3980 } 3981 3982 return nil 3983} 3984 3985func awsAwsjson11_serializeOpDocumentSearchFacesByImageInput(v *SearchFacesByImageInput, value smithyjson.Value) error { 3986 object := value.Object() 3987 defer object.Close() 3988 3989 if v.CollectionId != nil { 3990 ok := object.Key("CollectionId") 3991 ok.String(*v.CollectionId) 3992 } 3993 3994 if v.FaceMatchThreshold != nil { 3995 ok := object.Key("FaceMatchThreshold") 3996 switch { 3997 case math.IsNaN(float64(*v.FaceMatchThreshold)): 3998 ok.String("NaN") 3999 4000 case math.IsInf(float64(*v.FaceMatchThreshold), 1): 4001 ok.String("Infinity") 4002 4003 case math.IsInf(float64(*v.FaceMatchThreshold), -1): 4004 ok.String("-Infinity") 4005 4006 default: 4007 ok.Float(*v.FaceMatchThreshold) 4008 4009 } 4010 } 4011 4012 if v.Image != nil { 4013 ok := object.Key("Image") 4014 if err := awsAwsjson11_serializeDocumentImage(v.Image, ok); err != nil { 4015 return err 4016 } 4017 } 4018 4019 if v.MaxFaces != nil { 4020 ok := object.Key("MaxFaces") 4021 ok.Integer(*v.MaxFaces) 4022 } 4023 4024 if len(v.QualityFilter) > 0 { 4025 ok := object.Key("QualityFilter") 4026 ok.String(string(v.QualityFilter)) 4027 } 4028 4029 return nil 4030} 4031 4032func awsAwsjson11_serializeOpDocumentSearchFacesInput(v *SearchFacesInput, value smithyjson.Value) error { 4033 object := value.Object() 4034 defer object.Close() 4035 4036 if v.CollectionId != nil { 4037 ok := object.Key("CollectionId") 4038 ok.String(*v.CollectionId) 4039 } 4040 4041 if v.FaceId != nil { 4042 ok := object.Key("FaceId") 4043 ok.String(*v.FaceId) 4044 } 4045 4046 if v.FaceMatchThreshold != nil { 4047 ok := object.Key("FaceMatchThreshold") 4048 switch { 4049 case math.IsNaN(float64(*v.FaceMatchThreshold)): 4050 ok.String("NaN") 4051 4052 case math.IsInf(float64(*v.FaceMatchThreshold), 1): 4053 ok.String("Infinity") 4054 4055 case math.IsInf(float64(*v.FaceMatchThreshold), -1): 4056 ok.String("-Infinity") 4057 4058 default: 4059 ok.Float(*v.FaceMatchThreshold) 4060 4061 } 4062 } 4063 4064 if v.MaxFaces != nil { 4065 ok := object.Key("MaxFaces") 4066 ok.Integer(*v.MaxFaces) 4067 } 4068 4069 return nil 4070} 4071 4072func awsAwsjson11_serializeOpDocumentStartCelebrityRecognitionInput(v *StartCelebrityRecognitionInput, value smithyjson.Value) error { 4073 object := value.Object() 4074 defer object.Close() 4075 4076 if v.ClientRequestToken != nil { 4077 ok := object.Key("ClientRequestToken") 4078 ok.String(*v.ClientRequestToken) 4079 } 4080 4081 if v.JobTag != nil { 4082 ok := object.Key("JobTag") 4083 ok.String(*v.JobTag) 4084 } 4085 4086 if v.NotificationChannel != nil { 4087 ok := object.Key("NotificationChannel") 4088 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4089 return err 4090 } 4091 } 4092 4093 if v.Video != nil { 4094 ok := object.Key("Video") 4095 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4096 return err 4097 } 4098 } 4099 4100 return nil 4101} 4102 4103func awsAwsjson11_serializeOpDocumentStartContentModerationInput(v *StartContentModerationInput, value smithyjson.Value) error { 4104 object := value.Object() 4105 defer object.Close() 4106 4107 if v.ClientRequestToken != nil { 4108 ok := object.Key("ClientRequestToken") 4109 ok.String(*v.ClientRequestToken) 4110 } 4111 4112 if v.JobTag != nil { 4113 ok := object.Key("JobTag") 4114 ok.String(*v.JobTag) 4115 } 4116 4117 if v.MinConfidence != nil { 4118 ok := object.Key("MinConfidence") 4119 switch { 4120 case math.IsNaN(float64(*v.MinConfidence)): 4121 ok.String("NaN") 4122 4123 case math.IsInf(float64(*v.MinConfidence), 1): 4124 ok.String("Infinity") 4125 4126 case math.IsInf(float64(*v.MinConfidence), -1): 4127 ok.String("-Infinity") 4128 4129 default: 4130 ok.Float(*v.MinConfidence) 4131 4132 } 4133 } 4134 4135 if v.NotificationChannel != nil { 4136 ok := object.Key("NotificationChannel") 4137 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4138 return err 4139 } 4140 } 4141 4142 if v.Video != nil { 4143 ok := object.Key("Video") 4144 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4145 return err 4146 } 4147 } 4148 4149 return nil 4150} 4151 4152func awsAwsjson11_serializeOpDocumentStartFaceDetectionInput(v *StartFaceDetectionInput, value smithyjson.Value) error { 4153 object := value.Object() 4154 defer object.Close() 4155 4156 if v.ClientRequestToken != nil { 4157 ok := object.Key("ClientRequestToken") 4158 ok.String(*v.ClientRequestToken) 4159 } 4160 4161 if len(v.FaceAttributes) > 0 { 4162 ok := object.Key("FaceAttributes") 4163 ok.String(string(v.FaceAttributes)) 4164 } 4165 4166 if v.JobTag != nil { 4167 ok := object.Key("JobTag") 4168 ok.String(*v.JobTag) 4169 } 4170 4171 if v.NotificationChannel != nil { 4172 ok := object.Key("NotificationChannel") 4173 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4174 return err 4175 } 4176 } 4177 4178 if v.Video != nil { 4179 ok := object.Key("Video") 4180 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4181 return err 4182 } 4183 } 4184 4185 return nil 4186} 4187 4188func awsAwsjson11_serializeOpDocumentStartFaceSearchInput(v *StartFaceSearchInput, value smithyjson.Value) error { 4189 object := value.Object() 4190 defer object.Close() 4191 4192 if v.ClientRequestToken != nil { 4193 ok := object.Key("ClientRequestToken") 4194 ok.String(*v.ClientRequestToken) 4195 } 4196 4197 if v.CollectionId != nil { 4198 ok := object.Key("CollectionId") 4199 ok.String(*v.CollectionId) 4200 } 4201 4202 if v.FaceMatchThreshold != nil { 4203 ok := object.Key("FaceMatchThreshold") 4204 switch { 4205 case math.IsNaN(float64(*v.FaceMatchThreshold)): 4206 ok.String("NaN") 4207 4208 case math.IsInf(float64(*v.FaceMatchThreshold), 1): 4209 ok.String("Infinity") 4210 4211 case math.IsInf(float64(*v.FaceMatchThreshold), -1): 4212 ok.String("-Infinity") 4213 4214 default: 4215 ok.Float(*v.FaceMatchThreshold) 4216 4217 } 4218 } 4219 4220 if v.JobTag != nil { 4221 ok := object.Key("JobTag") 4222 ok.String(*v.JobTag) 4223 } 4224 4225 if v.NotificationChannel != nil { 4226 ok := object.Key("NotificationChannel") 4227 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4228 return err 4229 } 4230 } 4231 4232 if v.Video != nil { 4233 ok := object.Key("Video") 4234 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4235 return err 4236 } 4237 } 4238 4239 return nil 4240} 4241 4242func awsAwsjson11_serializeOpDocumentStartLabelDetectionInput(v *StartLabelDetectionInput, value smithyjson.Value) error { 4243 object := value.Object() 4244 defer object.Close() 4245 4246 if v.ClientRequestToken != nil { 4247 ok := object.Key("ClientRequestToken") 4248 ok.String(*v.ClientRequestToken) 4249 } 4250 4251 if v.JobTag != nil { 4252 ok := object.Key("JobTag") 4253 ok.String(*v.JobTag) 4254 } 4255 4256 if v.MinConfidence != nil { 4257 ok := object.Key("MinConfidence") 4258 switch { 4259 case math.IsNaN(float64(*v.MinConfidence)): 4260 ok.String("NaN") 4261 4262 case math.IsInf(float64(*v.MinConfidence), 1): 4263 ok.String("Infinity") 4264 4265 case math.IsInf(float64(*v.MinConfidence), -1): 4266 ok.String("-Infinity") 4267 4268 default: 4269 ok.Float(*v.MinConfidence) 4270 4271 } 4272 } 4273 4274 if v.NotificationChannel != nil { 4275 ok := object.Key("NotificationChannel") 4276 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4277 return err 4278 } 4279 } 4280 4281 if v.Video != nil { 4282 ok := object.Key("Video") 4283 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4284 return err 4285 } 4286 } 4287 4288 return nil 4289} 4290 4291func awsAwsjson11_serializeOpDocumentStartPersonTrackingInput(v *StartPersonTrackingInput, value smithyjson.Value) error { 4292 object := value.Object() 4293 defer object.Close() 4294 4295 if v.ClientRequestToken != nil { 4296 ok := object.Key("ClientRequestToken") 4297 ok.String(*v.ClientRequestToken) 4298 } 4299 4300 if v.JobTag != nil { 4301 ok := object.Key("JobTag") 4302 ok.String(*v.JobTag) 4303 } 4304 4305 if v.NotificationChannel != nil { 4306 ok := object.Key("NotificationChannel") 4307 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4308 return err 4309 } 4310 } 4311 4312 if v.Video != nil { 4313 ok := object.Key("Video") 4314 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4315 return err 4316 } 4317 } 4318 4319 return nil 4320} 4321 4322func awsAwsjson11_serializeOpDocumentStartProjectVersionInput(v *StartProjectVersionInput, value smithyjson.Value) error { 4323 object := value.Object() 4324 defer object.Close() 4325 4326 if v.MinInferenceUnits != nil { 4327 ok := object.Key("MinInferenceUnits") 4328 ok.Integer(*v.MinInferenceUnits) 4329 } 4330 4331 if v.ProjectVersionArn != nil { 4332 ok := object.Key("ProjectVersionArn") 4333 ok.String(*v.ProjectVersionArn) 4334 } 4335 4336 return nil 4337} 4338 4339func awsAwsjson11_serializeOpDocumentStartSegmentDetectionInput(v *StartSegmentDetectionInput, value smithyjson.Value) error { 4340 object := value.Object() 4341 defer object.Close() 4342 4343 if v.ClientRequestToken != nil { 4344 ok := object.Key("ClientRequestToken") 4345 ok.String(*v.ClientRequestToken) 4346 } 4347 4348 if v.Filters != nil { 4349 ok := object.Key("Filters") 4350 if err := awsAwsjson11_serializeDocumentStartSegmentDetectionFilters(v.Filters, ok); err != nil { 4351 return err 4352 } 4353 } 4354 4355 if v.JobTag != nil { 4356 ok := object.Key("JobTag") 4357 ok.String(*v.JobTag) 4358 } 4359 4360 if v.NotificationChannel != nil { 4361 ok := object.Key("NotificationChannel") 4362 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4363 return err 4364 } 4365 } 4366 4367 if v.SegmentTypes != nil { 4368 ok := object.Key("SegmentTypes") 4369 if err := awsAwsjson11_serializeDocumentSegmentTypes(v.SegmentTypes, ok); err != nil { 4370 return err 4371 } 4372 } 4373 4374 if v.Video != nil { 4375 ok := object.Key("Video") 4376 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4377 return err 4378 } 4379 } 4380 4381 return nil 4382} 4383 4384func awsAwsjson11_serializeOpDocumentStartStreamProcessorInput(v *StartStreamProcessorInput, value smithyjson.Value) error { 4385 object := value.Object() 4386 defer object.Close() 4387 4388 if v.Name != nil { 4389 ok := object.Key("Name") 4390 ok.String(*v.Name) 4391 } 4392 4393 return nil 4394} 4395 4396func awsAwsjson11_serializeOpDocumentStartTextDetectionInput(v *StartTextDetectionInput, value smithyjson.Value) error { 4397 object := value.Object() 4398 defer object.Close() 4399 4400 if v.ClientRequestToken != nil { 4401 ok := object.Key("ClientRequestToken") 4402 ok.String(*v.ClientRequestToken) 4403 } 4404 4405 if v.Filters != nil { 4406 ok := object.Key("Filters") 4407 if err := awsAwsjson11_serializeDocumentStartTextDetectionFilters(v.Filters, ok); err != nil { 4408 return err 4409 } 4410 } 4411 4412 if v.JobTag != nil { 4413 ok := object.Key("JobTag") 4414 ok.String(*v.JobTag) 4415 } 4416 4417 if v.NotificationChannel != nil { 4418 ok := object.Key("NotificationChannel") 4419 if err := awsAwsjson11_serializeDocumentNotificationChannel(v.NotificationChannel, ok); err != nil { 4420 return err 4421 } 4422 } 4423 4424 if v.Video != nil { 4425 ok := object.Key("Video") 4426 if err := awsAwsjson11_serializeDocumentVideo(v.Video, ok); err != nil { 4427 return err 4428 } 4429 } 4430 4431 return nil 4432} 4433 4434func awsAwsjson11_serializeOpDocumentStopProjectVersionInput(v *StopProjectVersionInput, value smithyjson.Value) error { 4435 object := value.Object() 4436 defer object.Close() 4437 4438 if v.ProjectVersionArn != nil { 4439 ok := object.Key("ProjectVersionArn") 4440 ok.String(*v.ProjectVersionArn) 4441 } 4442 4443 return nil 4444} 4445 4446func awsAwsjson11_serializeOpDocumentStopStreamProcessorInput(v *StopStreamProcessorInput, value smithyjson.Value) error { 4447 object := value.Object() 4448 defer object.Close() 4449 4450 if v.Name != nil { 4451 ok := object.Key("Name") 4452 ok.String(*v.Name) 4453 } 4454 4455 return nil 4456} 4457 4458func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 4459 object := value.Object() 4460 defer object.Close() 4461 4462 if v.ResourceArn != nil { 4463 ok := object.Key("ResourceArn") 4464 ok.String(*v.ResourceArn) 4465 } 4466 4467 if v.Tags != nil { 4468 ok := object.Key("Tags") 4469 if err := awsAwsjson11_serializeDocumentTagMap(v.Tags, ok); err != nil { 4470 return err 4471 } 4472 } 4473 4474 return nil 4475} 4476 4477func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error { 4478 object := value.Object() 4479 defer object.Close() 4480 4481 if v.ResourceArn != nil { 4482 ok := object.Key("ResourceArn") 4483 ok.String(*v.ResourceArn) 4484 } 4485 4486 if v.TagKeys != nil { 4487 ok := object.Key("TagKeys") 4488 if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil { 4489 return err 4490 } 4491 } 4492 4493 return nil 4494} 4495