1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package iotevents 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/iotevents/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpCreateDetectorModel struct { 18} 19 20func (*awsRestjson1_serializeOpCreateDetectorModel) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpCreateDetectorModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*CreateDetectorModelInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 opPath, opQuery := httpbinding.SplitURI("/detector-models") 39 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 40 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 41 request.Method = "POST" 42 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 43 if err != nil { 44 return out, metadata, &smithy.SerializationError{Err: err} 45 } 46 47 restEncoder.SetHeader("Content-Type").String("application/json") 48 49 jsonEncoder := smithyjson.NewEncoder() 50 if err := awsRestjson1_serializeOpDocumentCreateDetectorModelInput(input, jsonEncoder.Value); err != nil { 51 return out, metadata, &smithy.SerializationError{Err: err} 52 } 53 54 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 55 return out, metadata, &smithy.SerializationError{Err: err} 56 } 57 58 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 59 return out, metadata, &smithy.SerializationError{Err: err} 60 } 61 in.Request = request 62 63 return next.HandleSerialize(ctx, in) 64} 65func awsRestjson1_serializeOpHttpBindingsCreateDetectorModelInput(v *CreateDetectorModelInput, encoder *httpbinding.Encoder) error { 66 if v == nil { 67 return fmt.Errorf("unsupported serialization of nil %T", v) 68 } 69 70 return nil 71} 72 73func awsRestjson1_serializeOpDocumentCreateDetectorModelInput(v *CreateDetectorModelInput, value smithyjson.Value) error { 74 object := value.Object() 75 defer object.Close() 76 77 if v.DetectorModelDefinition != nil { 78 ok := object.Key("detectorModelDefinition") 79 if err := awsRestjson1_serializeDocumentDetectorModelDefinition(v.DetectorModelDefinition, ok); err != nil { 80 return err 81 } 82 } 83 84 if v.DetectorModelDescription != nil { 85 ok := object.Key("detectorModelDescription") 86 ok.String(*v.DetectorModelDescription) 87 } 88 89 if v.DetectorModelName != nil { 90 ok := object.Key("detectorModelName") 91 ok.String(*v.DetectorModelName) 92 } 93 94 if len(v.EvaluationMethod) > 0 { 95 ok := object.Key("evaluationMethod") 96 ok.String(string(v.EvaluationMethod)) 97 } 98 99 if v.Key != nil { 100 ok := object.Key("key") 101 ok.String(*v.Key) 102 } 103 104 if v.RoleArn != nil { 105 ok := object.Key("roleArn") 106 ok.String(*v.RoleArn) 107 } 108 109 if v.Tags != nil { 110 ok := object.Key("tags") 111 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 112 return err 113 } 114 } 115 116 return nil 117} 118 119type awsRestjson1_serializeOpCreateInput struct { 120} 121 122func (*awsRestjson1_serializeOpCreateInput) ID() string { 123 return "OperationSerializer" 124} 125 126func (m *awsRestjson1_serializeOpCreateInput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 127 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 128) { 129 request, ok := in.Request.(*smithyhttp.Request) 130 if !ok { 131 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 132 } 133 134 input, ok := in.Parameters.(*CreateInputInput) 135 _ = input 136 if !ok { 137 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 138 } 139 140 opPath, opQuery := httpbinding.SplitURI("/inputs") 141 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 142 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 143 request.Method = "POST" 144 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 145 if err != nil { 146 return out, metadata, &smithy.SerializationError{Err: err} 147 } 148 149 restEncoder.SetHeader("Content-Type").String("application/json") 150 151 jsonEncoder := smithyjson.NewEncoder() 152 if err := awsRestjson1_serializeOpDocumentCreateInputInput(input, jsonEncoder.Value); err != nil { 153 return out, metadata, &smithy.SerializationError{Err: err} 154 } 155 156 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 157 return out, metadata, &smithy.SerializationError{Err: err} 158 } 159 160 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 161 return out, metadata, &smithy.SerializationError{Err: err} 162 } 163 in.Request = request 164 165 return next.HandleSerialize(ctx, in) 166} 167func awsRestjson1_serializeOpHttpBindingsCreateInputInput(v *CreateInputInput, encoder *httpbinding.Encoder) error { 168 if v == nil { 169 return fmt.Errorf("unsupported serialization of nil %T", v) 170 } 171 172 return nil 173} 174 175func awsRestjson1_serializeOpDocumentCreateInputInput(v *CreateInputInput, value smithyjson.Value) error { 176 object := value.Object() 177 defer object.Close() 178 179 if v.InputDefinition != nil { 180 ok := object.Key("inputDefinition") 181 if err := awsRestjson1_serializeDocumentInputDefinition(v.InputDefinition, ok); err != nil { 182 return err 183 } 184 } 185 186 if v.InputDescription != nil { 187 ok := object.Key("inputDescription") 188 ok.String(*v.InputDescription) 189 } 190 191 if v.InputName != nil { 192 ok := object.Key("inputName") 193 ok.String(*v.InputName) 194 } 195 196 if v.Tags != nil { 197 ok := object.Key("tags") 198 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 199 return err 200 } 201 } 202 203 return nil 204} 205 206type awsRestjson1_serializeOpDeleteDetectorModel struct { 207} 208 209func (*awsRestjson1_serializeOpDeleteDetectorModel) ID() string { 210 return "OperationSerializer" 211} 212 213func (m *awsRestjson1_serializeOpDeleteDetectorModel) 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.(*DeleteDetectorModelInput) 222 _ = input 223 if !ok { 224 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 225 } 226 227 opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}") 228 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 229 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 230 request.Method = "DELETE" 231 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 232 if err != nil { 233 return out, metadata, &smithy.SerializationError{Err: err} 234 } 235 236 if err := awsRestjson1_serializeOpHttpBindingsDeleteDetectorModelInput(input, restEncoder); err != nil { 237 return out, metadata, &smithy.SerializationError{Err: err} 238 } 239 240 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 241 return out, metadata, &smithy.SerializationError{Err: err} 242 } 243 in.Request = request 244 245 return next.HandleSerialize(ctx, in) 246} 247func awsRestjson1_serializeOpHttpBindingsDeleteDetectorModelInput(v *DeleteDetectorModelInput, encoder *httpbinding.Encoder) error { 248 if v == nil { 249 return fmt.Errorf("unsupported serialization of nil %T", v) 250 } 251 252 if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 { 253 return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")} 254 } 255 if v.DetectorModelName != nil { 256 if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil { 257 return err 258 } 259 } 260 261 return nil 262} 263 264type awsRestjson1_serializeOpDeleteInput struct { 265} 266 267func (*awsRestjson1_serializeOpDeleteInput) ID() string { 268 return "OperationSerializer" 269} 270 271func (m *awsRestjson1_serializeOpDeleteInput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 272 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 273) { 274 request, ok := in.Request.(*smithyhttp.Request) 275 if !ok { 276 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 277 } 278 279 input, ok := in.Parameters.(*DeleteInputInput) 280 _ = input 281 if !ok { 282 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 283 } 284 285 opPath, opQuery := httpbinding.SplitURI("/inputs/{inputName}") 286 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 287 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 288 request.Method = "DELETE" 289 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 290 if err != nil { 291 return out, metadata, &smithy.SerializationError{Err: err} 292 } 293 294 if err := awsRestjson1_serializeOpHttpBindingsDeleteInputInput(input, restEncoder); err != nil { 295 return out, metadata, &smithy.SerializationError{Err: err} 296 } 297 298 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 299 return out, metadata, &smithy.SerializationError{Err: err} 300 } 301 in.Request = request 302 303 return next.HandleSerialize(ctx, in) 304} 305func awsRestjson1_serializeOpHttpBindingsDeleteInputInput(v *DeleteInputInput, encoder *httpbinding.Encoder) error { 306 if v == nil { 307 return fmt.Errorf("unsupported serialization of nil %T", v) 308 } 309 310 if v.InputName == nil || len(*v.InputName) == 0 { 311 return &smithy.SerializationError{Err: fmt.Errorf("input member inputName must not be empty")} 312 } 313 if v.InputName != nil { 314 if err := encoder.SetURI("inputName").String(*v.InputName); err != nil { 315 return err 316 } 317 } 318 319 return nil 320} 321 322type awsRestjson1_serializeOpDescribeDetectorModel struct { 323} 324 325func (*awsRestjson1_serializeOpDescribeDetectorModel) ID() string { 326 return "OperationSerializer" 327} 328 329func (m *awsRestjson1_serializeOpDescribeDetectorModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 330 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 331) { 332 request, ok := in.Request.(*smithyhttp.Request) 333 if !ok { 334 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 335 } 336 337 input, ok := in.Parameters.(*DescribeDetectorModelInput) 338 _ = input 339 if !ok { 340 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 341 } 342 343 opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}") 344 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 345 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 346 request.Method = "GET" 347 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 348 if err != nil { 349 return out, metadata, &smithy.SerializationError{Err: err} 350 } 351 352 if err := awsRestjson1_serializeOpHttpBindingsDescribeDetectorModelInput(input, restEncoder); err != nil { 353 return out, metadata, &smithy.SerializationError{Err: err} 354 } 355 356 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 357 return out, metadata, &smithy.SerializationError{Err: err} 358 } 359 in.Request = request 360 361 return next.HandleSerialize(ctx, in) 362} 363func awsRestjson1_serializeOpHttpBindingsDescribeDetectorModelInput(v *DescribeDetectorModelInput, encoder *httpbinding.Encoder) error { 364 if v == nil { 365 return fmt.Errorf("unsupported serialization of nil %T", v) 366 } 367 368 if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 { 369 return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")} 370 } 371 if v.DetectorModelName != nil { 372 if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil { 373 return err 374 } 375 } 376 377 if v.DetectorModelVersion != nil { 378 encoder.SetQuery("version").String(*v.DetectorModelVersion) 379 } 380 381 return nil 382} 383 384type awsRestjson1_serializeOpDescribeDetectorModelAnalysis struct { 385} 386 387func (*awsRestjson1_serializeOpDescribeDetectorModelAnalysis) ID() string { 388 return "OperationSerializer" 389} 390 391func (m *awsRestjson1_serializeOpDescribeDetectorModelAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 392 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 393) { 394 request, ok := in.Request.(*smithyhttp.Request) 395 if !ok { 396 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 397 } 398 399 input, ok := in.Parameters.(*DescribeDetectorModelAnalysisInput) 400 _ = input 401 if !ok { 402 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 403 } 404 405 opPath, opQuery := httpbinding.SplitURI("/analysis/detector-models/{analysisId}") 406 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 407 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 408 request.Method = "GET" 409 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 410 if err != nil { 411 return out, metadata, &smithy.SerializationError{Err: err} 412 } 413 414 if err := awsRestjson1_serializeOpHttpBindingsDescribeDetectorModelAnalysisInput(input, restEncoder); err != nil { 415 return out, metadata, &smithy.SerializationError{Err: err} 416 } 417 418 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 419 return out, metadata, &smithy.SerializationError{Err: err} 420 } 421 in.Request = request 422 423 return next.HandleSerialize(ctx, in) 424} 425func awsRestjson1_serializeOpHttpBindingsDescribeDetectorModelAnalysisInput(v *DescribeDetectorModelAnalysisInput, encoder *httpbinding.Encoder) error { 426 if v == nil { 427 return fmt.Errorf("unsupported serialization of nil %T", v) 428 } 429 430 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 431 return &smithy.SerializationError{Err: fmt.Errorf("input member analysisId must not be empty")} 432 } 433 if v.AnalysisId != nil { 434 if err := encoder.SetURI("analysisId").String(*v.AnalysisId); err != nil { 435 return err 436 } 437 } 438 439 return nil 440} 441 442type awsRestjson1_serializeOpDescribeInput struct { 443} 444 445func (*awsRestjson1_serializeOpDescribeInput) ID() string { 446 return "OperationSerializer" 447} 448 449func (m *awsRestjson1_serializeOpDescribeInput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 450 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 451) { 452 request, ok := in.Request.(*smithyhttp.Request) 453 if !ok { 454 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 455 } 456 457 input, ok := in.Parameters.(*DescribeInputInput) 458 _ = input 459 if !ok { 460 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 461 } 462 463 opPath, opQuery := httpbinding.SplitURI("/inputs/{inputName}") 464 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 465 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 466 request.Method = "GET" 467 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 468 if err != nil { 469 return out, metadata, &smithy.SerializationError{Err: err} 470 } 471 472 if err := awsRestjson1_serializeOpHttpBindingsDescribeInputInput(input, restEncoder); err != nil { 473 return out, metadata, &smithy.SerializationError{Err: err} 474 } 475 476 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 477 return out, metadata, &smithy.SerializationError{Err: err} 478 } 479 in.Request = request 480 481 return next.HandleSerialize(ctx, in) 482} 483func awsRestjson1_serializeOpHttpBindingsDescribeInputInput(v *DescribeInputInput, encoder *httpbinding.Encoder) error { 484 if v == nil { 485 return fmt.Errorf("unsupported serialization of nil %T", v) 486 } 487 488 if v.InputName == nil || len(*v.InputName) == 0 { 489 return &smithy.SerializationError{Err: fmt.Errorf("input member inputName must not be empty")} 490 } 491 if v.InputName != nil { 492 if err := encoder.SetURI("inputName").String(*v.InputName); err != nil { 493 return err 494 } 495 } 496 497 return nil 498} 499 500type awsRestjson1_serializeOpDescribeLoggingOptions struct { 501} 502 503func (*awsRestjson1_serializeOpDescribeLoggingOptions) ID() string { 504 return "OperationSerializer" 505} 506 507func (m *awsRestjson1_serializeOpDescribeLoggingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 508 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 509) { 510 request, ok := in.Request.(*smithyhttp.Request) 511 if !ok { 512 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 513 } 514 515 input, ok := in.Parameters.(*DescribeLoggingOptionsInput) 516 _ = input 517 if !ok { 518 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 519 } 520 521 opPath, opQuery := httpbinding.SplitURI("/logging") 522 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 523 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 524 request.Method = "GET" 525 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 526 if err != nil { 527 return out, metadata, &smithy.SerializationError{Err: err} 528 } 529 530 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 531 return out, metadata, &smithy.SerializationError{Err: err} 532 } 533 in.Request = request 534 535 return next.HandleSerialize(ctx, in) 536} 537func awsRestjson1_serializeOpHttpBindingsDescribeLoggingOptionsInput(v *DescribeLoggingOptionsInput, encoder *httpbinding.Encoder) error { 538 if v == nil { 539 return fmt.Errorf("unsupported serialization of nil %T", v) 540 } 541 542 return nil 543} 544 545type awsRestjson1_serializeOpGetDetectorModelAnalysisResults struct { 546} 547 548func (*awsRestjson1_serializeOpGetDetectorModelAnalysisResults) ID() string { 549 return "OperationSerializer" 550} 551 552func (m *awsRestjson1_serializeOpGetDetectorModelAnalysisResults) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 553 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 554) { 555 request, ok := in.Request.(*smithyhttp.Request) 556 if !ok { 557 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 558 } 559 560 input, ok := in.Parameters.(*GetDetectorModelAnalysisResultsInput) 561 _ = input 562 if !ok { 563 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 564 } 565 566 opPath, opQuery := httpbinding.SplitURI("/analysis/detector-models/{analysisId}/results") 567 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 568 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 569 request.Method = "GET" 570 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 571 if err != nil { 572 return out, metadata, &smithy.SerializationError{Err: err} 573 } 574 575 if err := awsRestjson1_serializeOpHttpBindingsGetDetectorModelAnalysisResultsInput(input, restEncoder); err != nil { 576 return out, metadata, &smithy.SerializationError{Err: err} 577 } 578 579 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 580 return out, metadata, &smithy.SerializationError{Err: err} 581 } 582 in.Request = request 583 584 return next.HandleSerialize(ctx, in) 585} 586func awsRestjson1_serializeOpHttpBindingsGetDetectorModelAnalysisResultsInput(v *GetDetectorModelAnalysisResultsInput, encoder *httpbinding.Encoder) error { 587 if v == nil { 588 return fmt.Errorf("unsupported serialization of nil %T", v) 589 } 590 591 if v.AnalysisId == nil || len(*v.AnalysisId) == 0 { 592 return &smithy.SerializationError{Err: fmt.Errorf("input member analysisId must not be empty")} 593 } 594 if v.AnalysisId != nil { 595 if err := encoder.SetURI("analysisId").String(*v.AnalysisId); err != nil { 596 return err 597 } 598 } 599 600 if v.MaxResults != nil { 601 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 602 } 603 604 if v.NextToken != nil { 605 encoder.SetQuery("nextToken").String(*v.NextToken) 606 } 607 608 return nil 609} 610 611type awsRestjson1_serializeOpListDetectorModels struct { 612} 613 614func (*awsRestjson1_serializeOpListDetectorModels) ID() string { 615 return "OperationSerializer" 616} 617 618func (m *awsRestjson1_serializeOpListDetectorModels) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 619 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 620) { 621 request, ok := in.Request.(*smithyhttp.Request) 622 if !ok { 623 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 624 } 625 626 input, ok := in.Parameters.(*ListDetectorModelsInput) 627 _ = input 628 if !ok { 629 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 630 } 631 632 opPath, opQuery := httpbinding.SplitURI("/detector-models") 633 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 634 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 635 request.Method = "GET" 636 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 637 if err != nil { 638 return out, metadata, &smithy.SerializationError{Err: err} 639 } 640 641 if err := awsRestjson1_serializeOpHttpBindingsListDetectorModelsInput(input, restEncoder); err != nil { 642 return out, metadata, &smithy.SerializationError{Err: err} 643 } 644 645 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 646 return out, metadata, &smithy.SerializationError{Err: err} 647 } 648 in.Request = request 649 650 return next.HandleSerialize(ctx, in) 651} 652func awsRestjson1_serializeOpHttpBindingsListDetectorModelsInput(v *ListDetectorModelsInput, encoder *httpbinding.Encoder) error { 653 if v == nil { 654 return fmt.Errorf("unsupported serialization of nil %T", v) 655 } 656 657 if v.MaxResults != nil { 658 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 659 } 660 661 if v.NextToken != nil { 662 encoder.SetQuery("nextToken").String(*v.NextToken) 663 } 664 665 return nil 666} 667 668type awsRestjson1_serializeOpListDetectorModelVersions struct { 669} 670 671func (*awsRestjson1_serializeOpListDetectorModelVersions) ID() string { 672 return "OperationSerializer" 673} 674 675func (m *awsRestjson1_serializeOpListDetectorModelVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 676 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 677) { 678 request, ok := in.Request.(*smithyhttp.Request) 679 if !ok { 680 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 681 } 682 683 input, ok := in.Parameters.(*ListDetectorModelVersionsInput) 684 _ = input 685 if !ok { 686 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 687 } 688 689 opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}/versions") 690 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 691 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 692 request.Method = "GET" 693 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 694 if err != nil { 695 return out, metadata, &smithy.SerializationError{Err: err} 696 } 697 698 if err := awsRestjson1_serializeOpHttpBindingsListDetectorModelVersionsInput(input, restEncoder); err != nil { 699 return out, metadata, &smithy.SerializationError{Err: err} 700 } 701 702 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 703 return out, metadata, &smithy.SerializationError{Err: err} 704 } 705 in.Request = request 706 707 return next.HandleSerialize(ctx, in) 708} 709func awsRestjson1_serializeOpHttpBindingsListDetectorModelVersionsInput(v *ListDetectorModelVersionsInput, encoder *httpbinding.Encoder) error { 710 if v == nil { 711 return fmt.Errorf("unsupported serialization of nil %T", v) 712 } 713 714 if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 { 715 return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")} 716 } 717 if v.DetectorModelName != nil { 718 if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil { 719 return err 720 } 721 } 722 723 if v.MaxResults != nil { 724 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 725 } 726 727 if v.NextToken != nil { 728 encoder.SetQuery("nextToken").String(*v.NextToken) 729 } 730 731 return nil 732} 733 734type awsRestjson1_serializeOpListInputs struct { 735} 736 737func (*awsRestjson1_serializeOpListInputs) ID() string { 738 return "OperationSerializer" 739} 740 741func (m *awsRestjson1_serializeOpListInputs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 742 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 743) { 744 request, ok := in.Request.(*smithyhttp.Request) 745 if !ok { 746 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 747 } 748 749 input, ok := in.Parameters.(*ListInputsInput) 750 _ = input 751 if !ok { 752 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 753 } 754 755 opPath, opQuery := httpbinding.SplitURI("/inputs") 756 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 757 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 758 request.Method = "GET" 759 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 760 if err != nil { 761 return out, metadata, &smithy.SerializationError{Err: err} 762 } 763 764 if err := awsRestjson1_serializeOpHttpBindingsListInputsInput(input, restEncoder); err != nil { 765 return out, metadata, &smithy.SerializationError{Err: err} 766 } 767 768 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 769 return out, metadata, &smithy.SerializationError{Err: err} 770 } 771 in.Request = request 772 773 return next.HandleSerialize(ctx, in) 774} 775func awsRestjson1_serializeOpHttpBindingsListInputsInput(v *ListInputsInput, encoder *httpbinding.Encoder) error { 776 if v == nil { 777 return fmt.Errorf("unsupported serialization of nil %T", v) 778 } 779 780 if v.MaxResults != nil { 781 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 782 } 783 784 if v.NextToken != nil { 785 encoder.SetQuery("nextToken").String(*v.NextToken) 786 } 787 788 return nil 789} 790 791type awsRestjson1_serializeOpListTagsForResource struct { 792} 793 794func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 795 return "OperationSerializer" 796} 797 798func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 799 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 800) { 801 request, ok := in.Request.(*smithyhttp.Request) 802 if !ok { 803 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 804 } 805 806 input, ok := in.Parameters.(*ListTagsForResourceInput) 807 _ = input 808 if !ok { 809 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 810 } 811 812 opPath, opQuery := httpbinding.SplitURI("/tags") 813 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 814 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 815 request.Method = "GET" 816 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 817 if err != nil { 818 return out, metadata, &smithy.SerializationError{Err: err} 819 } 820 821 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 822 return out, metadata, &smithy.SerializationError{Err: err} 823 } 824 825 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 826 return out, metadata, &smithy.SerializationError{Err: err} 827 } 828 in.Request = request 829 830 return next.HandleSerialize(ctx, in) 831} 832func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 833 if v == nil { 834 return fmt.Errorf("unsupported serialization of nil %T", v) 835 } 836 837 if v.ResourceArn != nil { 838 encoder.SetQuery("resourceArn").String(*v.ResourceArn) 839 } 840 841 return nil 842} 843 844type awsRestjson1_serializeOpPutLoggingOptions struct { 845} 846 847func (*awsRestjson1_serializeOpPutLoggingOptions) ID() string { 848 return "OperationSerializer" 849} 850 851func (m *awsRestjson1_serializeOpPutLoggingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 852 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 853) { 854 request, ok := in.Request.(*smithyhttp.Request) 855 if !ok { 856 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 857 } 858 859 input, ok := in.Parameters.(*PutLoggingOptionsInput) 860 _ = input 861 if !ok { 862 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 863 } 864 865 opPath, opQuery := httpbinding.SplitURI("/logging") 866 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 867 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 868 request.Method = "PUT" 869 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 870 if err != nil { 871 return out, metadata, &smithy.SerializationError{Err: err} 872 } 873 874 restEncoder.SetHeader("Content-Type").String("application/json") 875 876 jsonEncoder := smithyjson.NewEncoder() 877 if err := awsRestjson1_serializeOpDocumentPutLoggingOptionsInput(input, jsonEncoder.Value); err != nil { 878 return out, metadata, &smithy.SerializationError{Err: err} 879 } 880 881 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 882 return out, metadata, &smithy.SerializationError{Err: err} 883 } 884 885 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 886 return out, metadata, &smithy.SerializationError{Err: err} 887 } 888 in.Request = request 889 890 return next.HandleSerialize(ctx, in) 891} 892func awsRestjson1_serializeOpHttpBindingsPutLoggingOptionsInput(v *PutLoggingOptionsInput, encoder *httpbinding.Encoder) error { 893 if v == nil { 894 return fmt.Errorf("unsupported serialization of nil %T", v) 895 } 896 897 return nil 898} 899 900func awsRestjson1_serializeOpDocumentPutLoggingOptionsInput(v *PutLoggingOptionsInput, value smithyjson.Value) error { 901 object := value.Object() 902 defer object.Close() 903 904 if v.LoggingOptions != nil { 905 ok := object.Key("loggingOptions") 906 if err := awsRestjson1_serializeDocumentLoggingOptions(v.LoggingOptions, ok); err != nil { 907 return err 908 } 909 } 910 911 return nil 912} 913 914type awsRestjson1_serializeOpStartDetectorModelAnalysis struct { 915} 916 917func (*awsRestjson1_serializeOpStartDetectorModelAnalysis) ID() string { 918 return "OperationSerializer" 919} 920 921func (m *awsRestjson1_serializeOpStartDetectorModelAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 922 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 923) { 924 request, ok := in.Request.(*smithyhttp.Request) 925 if !ok { 926 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 927 } 928 929 input, ok := in.Parameters.(*StartDetectorModelAnalysisInput) 930 _ = input 931 if !ok { 932 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 933 } 934 935 opPath, opQuery := httpbinding.SplitURI("/analysis/detector-models") 936 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 937 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 938 request.Method = "POST" 939 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 940 if err != nil { 941 return out, metadata, &smithy.SerializationError{Err: err} 942 } 943 944 restEncoder.SetHeader("Content-Type").String("application/json") 945 946 jsonEncoder := smithyjson.NewEncoder() 947 if err := awsRestjson1_serializeOpDocumentStartDetectorModelAnalysisInput(input, jsonEncoder.Value); err != nil { 948 return out, metadata, &smithy.SerializationError{Err: err} 949 } 950 951 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 952 return out, metadata, &smithy.SerializationError{Err: err} 953 } 954 955 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 956 return out, metadata, &smithy.SerializationError{Err: err} 957 } 958 in.Request = request 959 960 return next.HandleSerialize(ctx, in) 961} 962func awsRestjson1_serializeOpHttpBindingsStartDetectorModelAnalysisInput(v *StartDetectorModelAnalysisInput, encoder *httpbinding.Encoder) error { 963 if v == nil { 964 return fmt.Errorf("unsupported serialization of nil %T", v) 965 } 966 967 return nil 968} 969 970func awsRestjson1_serializeOpDocumentStartDetectorModelAnalysisInput(v *StartDetectorModelAnalysisInput, value smithyjson.Value) error { 971 object := value.Object() 972 defer object.Close() 973 974 if v.DetectorModelDefinition != nil { 975 ok := object.Key("detectorModelDefinition") 976 if err := awsRestjson1_serializeDocumentDetectorModelDefinition(v.DetectorModelDefinition, ok); err != nil { 977 return err 978 } 979 } 980 981 return nil 982} 983 984type awsRestjson1_serializeOpTagResource struct { 985} 986 987func (*awsRestjson1_serializeOpTagResource) ID() string { 988 return "OperationSerializer" 989} 990 991func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 992 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 993) { 994 request, ok := in.Request.(*smithyhttp.Request) 995 if !ok { 996 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 997 } 998 999 input, ok := in.Parameters.(*TagResourceInput) 1000 _ = input 1001 if !ok { 1002 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1003 } 1004 1005 opPath, opQuery := httpbinding.SplitURI("/tags") 1006 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1007 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1008 request.Method = "POST" 1009 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1010 if err != nil { 1011 return out, metadata, &smithy.SerializationError{Err: err} 1012 } 1013 1014 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 1015 return out, metadata, &smithy.SerializationError{Err: err} 1016 } 1017 1018 restEncoder.SetHeader("Content-Type").String("application/json") 1019 1020 jsonEncoder := smithyjson.NewEncoder() 1021 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1022 return out, metadata, &smithy.SerializationError{Err: err} 1023 } 1024 1025 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1026 return out, metadata, &smithy.SerializationError{Err: err} 1027 } 1028 1029 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1030 return out, metadata, &smithy.SerializationError{Err: err} 1031 } 1032 in.Request = request 1033 1034 return next.HandleSerialize(ctx, in) 1035} 1036func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 1037 if v == nil { 1038 return fmt.Errorf("unsupported serialization of nil %T", v) 1039 } 1040 1041 if v.ResourceArn != nil { 1042 encoder.SetQuery("resourceArn").String(*v.ResourceArn) 1043 } 1044 1045 return nil 1046} 1047 1048func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 1049 object := value.Object() 1050 defer object.Close() 1051 1052 if v.Tags != nil { 1053 ok := object.Key("tags") 1054 if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil { 1055 return err 1056 } 1057 } 1058 1059 return nil 1060} 1061 1062type awsRestjson1_serializeOpUntagResource struct { 1063} 1064 1065func (*awsRestjson1_serializeOpUntagResource) ID() string { 1066 return "OperationSerializer" 1067} 1068 1069func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1070 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1071) { 1072 request, ok := in.Request.(*smithyhttp.Request) 1073 if !ok { 1074 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1075 } 1076 1077 input, ok := in.Parameters.(*UntagResourceInput) 1078 _ = input 1079 if !ok { 1080 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1081 } 1082 1083 opPath, opQuery := httpbinding.SplitURI("/tags") 1084 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1085 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1086 request.Method = "DELETE" 1087 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1088 if err != nil { 1089 return out, metadata, &smithy.SerializationError{Err: err} 1090 } 1091 1092 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 1093 return out, metadata, &smithy.SerializationError{Err: err} 1094 } 1095 1096 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1097 return out, metadata, &smithy.SerializationError{Err: err} 1098 } 1099 in.Request = request 1100 1101 return next.HandleSerialize(ctx, in) 1102} 1103func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 1104 if v == nil { 1105 return fmt.Errorf("unsupported serialization of nil %T", v) 1106 } 1107 1108 if v.ResourceArn != nil { 1109 encoder.SetQuery("resourceArn").String(*v.ResourceArn) 1110 } 1111 1112 if v.TagKeys != nil { 1113 for i := range v.TagKeys { 1114 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 1115 } 1116 } 1117 1118 return nil 1119} 1120 1121type awsRestjson1_serializeOpUpdateDetectorModel struct { 1122} 1123 1124func (*awsRestjson1_serializeOpUpdateDetectorModel) ID() string { 1125 return "OperationSerializer" 1126} 1127 1128func (m *awsRestjson1_serializeOpUpdateDetectorModel) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1129 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1130) { 1131 request, ok := in.Request.(*smithyhttp.Request) 1132 if !ok { 1133 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1134 } 1135 1136 input, ok := in.Parameters.(*UpdateDetectorModelInput) 1137 _ = input 1138 if !ok { 1139 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1140 } 1141 1142 opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}") 1143 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1144 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1145 request.Method = "POST" 1146 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1147 if err != nil { 1148 return out, metadata, &smithy.SerializationError{Err: err} 1149 } 1150 1151 if err := awsRestjson1_serializeOpHttpBindingsUpdateDetectorModelInput(input, restEncoder); err != nil { 1152 return out, metadata, &smithy.SerializationError{Err: err} 1153 } 1154 1155 restEncoder.SetHeader("Content-Type").String("application/json") 1156 1157 jsonEncoder := smithyjson.NewEncoder() 1158 if err := awsRestjson1_serializeOpDocumentUpdateDetectorModelInput(input, jsonEncoder.Value); err != nil { 1159 return out, metadata, &smithy.SerializationError{Err: err} 1160 } 1161 1162 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1163 return out, metadata, &smithy.SerializationError{Err: err} 1164 } 1165 1166 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1167 return out, metadata, &smithy.SerializationError{Err: err} 1168 } 1169 in.Request = request 1170 1171 return next.HandleSerialize(ctx, in) 1172} 1173func awsRestjson1_serializeOpHttpBindingsUpdateDetectorModelInput(v *UpdateDetectorModelInput, encoder *httpbinding.Encoder) error { 1174 if v == nil { 1175 return fmt.Errorf("unsupported serialization of nil %T", v) 1176 } 1177 1178 if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 { 1179 return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")} 1180 } 1181 if v.DetectorModelName != nil { 1182 if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil { 1183 return err 1184 } 1185 } 1186 1187 return nil 1188} 1189 1190func awsRestjson1_serializeOpDocumentUpdateDetectorModelInput(v *UpdateDetectorModelInput, value smithyjson.Value) error { 1191 object := value.Object() 1192 defer object.Close() 1193 1194 if v.DetectorModelDefinition != nil { 1195 ok := object.Key("detectorModelDefinition") 1196 if err := awsRestjson1_serializeDocumentDetectorModelDefinition(v.DetectorModelDefinition, ok); err != nil { 1197 return err 1198 } 1199 } 1200 1201 if v.DetectorModelDescription != nil { 1202 ok := object.Key("detectorModelDescription") 1203 ok.String(*v.DetectorModelDescription) 1204 } 1205 1206 if len(v.EvaluationMethod) > 0 { 1207 ok := object.Key("evaluationMethod") 1208 ok.String(string(v.EvaluationMethod)) 1209 } 1210 1211 if v.RoleArn != nil { 1212 ok := object.Key("roleArn") 1213 ok.String(*v.RoleArn) 1214 } 1215 1216 return nil 1217} 1218 1219type awsRestjson1_serializeOpUpdateInput struct { 1220} 1221 1222func (*awsRestjson1_serializeOpUpdateInput) ID() string { 1223 return "OperationSerializer" 1224} 1225 1226func (m *awsRestjson1_serializeOpUpdateInput) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1227 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1228) { 1229 request, ok := in.Request.(*smithyhttp.Request) 1230 if !ok { 1231 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1232 } 1233 1234 input, ok := in.Parameters.(*UpdateInputInput) 1235 _ = input 1236 if !ok { 1237 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1238 } 1239 1240 opPath, opQuery := httpbinding.SplitURI("/inputs/{inputName}") 1241 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1242 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1243 request.Method = "PUT" 1244 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1245 if err != nil { 1246 return out, metadata, &smithy.SerializationError{Err: err} 1247 } 1248 1249 if err := awsRestjson1_serializeOpHttpBindingsUpdateInputInput(input, restEncoder); err != nil { 1250 return out, metadata, &smithy.SerializationError{Err: err} 1251 } 1252 1253 restEncoder.SetHeader("Content-Type").String("application/json") 1254 1255 jsonEncoder := smithyjson.NewEncoder() 1256 if err := awsRestjson1_serializeOpDocumentUpdateInputInput(input, jsonEncoder.Value); err != nil { 1257 return out, metadata, &smithy.SerializationError{Err: err} 1258 } 1259 1260 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1261 return out, metadata, &smithy.SerializationError{Err: err} 1262 } 1263 1264 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1265 return out, metadata, &smithy.SerializationError{Err: err} 1266 } 1267 in.Request = request 1268 1269 return next.HandleSerialize(ctx, in) 1270} 1271func awsRestjson1_serializeOpHttpBindingsUpdateInputInput(v *UpdateInputInput, encoder *httpbinding.Encoder) error { 1272 if v == nil { 1273 return fmt.Errorf("unsupported serialization of nil %T", v) 1274 } 1275 1276 if v.InputName == nil || len(*v.InputName) == 0 { 1277 return &smithy.SerializationError{Err: fmt.Errorf("input member inputName must not be empty")} 1278 } 1279 if v.InputName != nil { 1280 if err := encoder.SetURI("inputName").String(*v.InputName); err != nil { 1281 return err 1282 } 1283 } 1284 1285 return nil 1286} 1287 1288func awsRestjson1_serializeOpDocumentUpdateInputInput(v *UpdateInputInput, value smithyjson.Value) error { 1289 object := value.Object() 1290 defer object.Close() 1291 1292 if v.InputDefinition != nil { 1293 ok := object.Key("inputDefinition") 1294 if err := awsRestjson1_serializeDocumentInputDefinition(v.InputDefinition, ok); err != nil { 1295 return err 1296 } 1297 } 1298 1299 if v.InputDescription != nil { 1300 ok := object.Key("inputDescription") 1301 ok.String(*v.InputDescription) 1302 } 1303 1304 return nil 1305} 1306 1307func awsRestjson1_serializeDocumentAction(v *types.Action, value smithyjson.Value) error { 1308 object := value.Object() 1309 defer object.Close() 1310 1311 if v.ClearTimer != nil { 1312 ok := object.Key("clearTimer") 1313 if err := awsRestjson1_serializeDocumentClearTimerAction(v.ClearTimer, ok); err != nil { 1314 return err 1315 } 1316 } 1317 1318 if v.DynamoDB != nil { 1319 ok := object.Key("dynamoDB") 1320 if err := awsRestjson1_serializeDocumentDynamoDBAction(v.DynamoDB, ok); err != nil { 1321 return err 1322 } 1323 } 1324 1325 if v.DynamoDBv2 != nil { 1326 ok := object.Key("dynamoDBv2") 1327 if err := awsRestjson1_serializeDocumentDynamoDBv2Action(v.DynamoDBv2, ok); err != nil { 1328 return err 1329 } 1330 } 1331 1332 if v.Firehose != nil { 1333 ok := object.Key("firehose") 1334 if err := awsRestjson1_serializeDocumentFirehoseAction(v.Firehose, ok); err != nil { 1335 return err 1336 } 1337 } 1338 1339 if v.IotEvents != nil { 1340 ok := object.Key("iotEvents") 1341 if err := awsRestjson1_serializeDocumentIotEventsAction(v.IotEvents, ok); err != nil { 1342 return err 1343 } 1344 } 1345 1346 if v.IotSiteWise != nil { 1347 ok := object.Key("iotSiteWise") 1348 if err := awsRestjson1_serializeDocumentIotSiteWiseAction(v.IotSiteWise, ok); err != nil { 1349 return err 1350 } 1351 } 1352 1353 if v.IotTopicPublish != nil { 1354 ok := object.Key("iotTopicPublish") 1355 if err := awsRestjson1_serializeDocumentIotTopicPublishAction(v.IotTopicPublish, ok); err != nil { 1356 return err 1357 } 1358 } 1359 1360 if v.Lambda != nil { 1361 ok := object.Key("lambda") 1362 if err := awsRestjson1_serializeDocumentLambdaAction(v.Lambda, ok); err != nil { 1363 return err 1364 } 1365 } 1366 1367 if v.ResetTimer != nil { 1368 ok := object.Key("resetTimer") 1369 if err := awsRestjson1_serializeDocumentResetTimerAction(v.ResetTimer, ok); err != nil { 1370 return err 1371 } 1372 } 1373 1374 if v.SetTimer != nil { 1375 ok := object.Key("setTimer") 1376 if err := awsRestjson1_serializeDocumentSetTimerAction(v.SetTimer, ok); err != nil { 1377 return err 1378 } 1379 } 1380 1381 if v.SetVariable != nil { 1382 ok := object.Key("setVariable") 1383 if err := awsRestjson1_serializeDocumentSetVariableAction(v.SetVariable, ok); err != nil { 1384 return err 1385 } 1386 } 1387 1388 if v.Sns != nil { 1389 ok := object.Key("sns") 1390 if err := awsRestjson1_serializeDocumentSNSTopicPublishAction(v.Sns, ok); err != nil { 1391 return err 1392 } 1393 } 1394 1395 if v.Sqs != nil { 1396 ok := object.Key("sqs") 1397 if err := awsRestjson1_serializeDocumentSqsAction(v.Sqs, ok); err != nil { 1398 return err 1399 } 1400 } 1401 1402 return nil 1403} 1404 1405func awsRestjson1_serializeDocumentActions(v []types.Action, value smithyjson.Value) error { 1406 array := value.Array() 1407 defer array.Close() 1408 1409 for i := range v { 1410 av := array.Value() 1411 if err := awsRestjson1_serializeDocumentAction(&v[i], av); err != nil { 1412 return err 1413 } 1414 } 1415 return nil 1416} 1417 1418func awsRestjson1_serializeDocumentAssetPropertyTimestamp(v *types.AssetPropertyTimestamp, value smithyjson.Value) error { 1419 object := value.Object() 1420 defer object.Close() 1421 1422 if v.OffsetInNanos != nil { 1423 ok := object.Key("offsetInNanos") 1424 ok.String(*v.OffsetInNanos) 1425 } 1426 1427 if v.TimeInSeconds != nil { 1428 ok := object.Key("timeInSeconds") 1429 ok.String(*v.TimeInSeconds) 1430 } 1431 1432 return nil 1433} 1434 1435func awsRestjson1_serializeDocumentAssetPropertyValue(v *types.AssetPropertyValue, value smithyjson.Value) error { 1436 object := value.Object() 1437 defer object.Close() 1438 1439 if v.Quality != nil { 1440 ok := object.Key("quality") 1441 ok.String(*v.Quality) 1442 } 1443 1444 if v.Timestamp != nil { 1445 ok := object.Key("timestamp") 1446 if err := awsRestjson1_serializeDocumentAssetPropertyTimestamp(v.Timestamp, ok); err != nil { 1447 return err 1448 } 1449 } 1450 1451 if v.Value != nil { 1452 ok := object.Key("value") 1453 if err := awsRestjson1_serializeDocumentAssetPropertyVariant(v.Value, ok); err != nil { 1454 return err 1455 } 1456 } 1457 1458 return nil 1459} 1460 1461func awsRestjson1_serializeDocumentAssetPropertyVariant(v *types.AssetPropertyVariant, value smithyjson.Value) error { 1462 object := value.Object() 1463 defer object.Close() 1464 1465 if v.BooleanValue != nil { 1466 ok := object.Key("booleanValue") 1467 ok.String(*v.BooleanValue) 1468 } 1469 1470 if v.DoubleValue != nil { 1471 ok := object.Key("doubleValue") 1472 ok.String(*v.DoubleValue) 1473 } 1474 1475 if v.IntegerValue != nil { 1476 ok := object.Key("integerValue") 1477 ok.String(*v.IntegerValue) 1478 } 1479 1480 if v.StringValue != nil { 1481 ok := object.Key("stringValue") 1482 ok.String(*v.StringValue) 1483 } 1484 1485 return nil 1486} 1487 1488func awsRestjson1_serializeDocumentAttribute(v *types.Attribute, value smithyjson.Value) error { 1489 object := value.Object() 1490 defer object.Close() 1491 1492 if v.JsonPath != nil { 1493 ok := object.Key("jsonPath") 1494 ok.String(*v.JsonPath) 1495 } 1496 1497 return nil 1498} 1499 1500func awsRestjson1_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error { 1501 array := value.Array() 1502 defer array.Close() 1503 1504 for i := range v { 1505 av := array.Value() 1506 if err := awsRestjson1_serializeDocumentAttribute(&v[i], av); err != nil { 1507 return err 1508 } 1509 } 1510 return nil 1511} 1512 1513func awsRestjson1_serializeDocumentClearTimerAction(v *types.ClearTimerAction, value smithyjson.Value) error { 1514 object := value.Object() 1515 defer object.Close() 1516 1517 if v.TimerName != nil { 1518 ok := object.Key("timerName") 1519 ok.String(*v.TimerName) 1520 } 1521 1522 return nil 1523} 1524 1525func awsRestjson1_serializeDocumentDetectorDebugOption(v *types.DetectorDebugOption, value smithyjson.Value) error { 1526 object := value.Object() 1527 defer object.Close() 1528 1529 if v.DetectorModelName != nil { 1530 ok := object.Key("detectorModelName") 1531 ok.String(*v.DetectorModelName) 1532 } 1533 1534 if v.KeyValue != nil { 1535 ok := object.Key("keyValue") 1536 ok.String(*v.KeyValue) 1537 } 1538 1539 return nil 1540} 1541 1542func awsRestjson1_serializeDocumentDetectorDebugOptions(v []types.DetectorDebugOption, value smithyjson.Value) error { 1543 array := value.Array() 1544 defer array.Close() 1545 1546 for i := range v { 1547 av := array.Value() 1548 if err := awsRestjson1_serializeDocumentDetectorDebugOption(&v[i], av); err != nil { 1549 return err 1550 } 1551 } 1552 return nil 1553} 1554 1555func awsRestjson1_serializeDocumentDetectorModelDefinition(v *types.DetectorModelDefinition, value smithyjson.Value) error { 1556 object := value.Object() 1557 defer object.Close() 1558 1559 if v.InitialStateName != nil { 1560 ok := object.Key("initialStateName") 1561 ok.String(*v.InitialStateName) 1562 } 1563 1564 if v.States != nil { 1565 ok := object.Key("states") 1566 if err := awsRestjson1_serializeDocumentStates(v.States, ok); err != nil { 1567 return err 1568 } 1569 } 1570 1571 return nil 1572} 1573 1574func awsRestjson1_serializeDocumentDynamoDBAction(v *types.DynamoDBAction, value smithyjson.Value) error { 1575 object := value.Object() 1576 defer object.Close() 1577 1578 if v.HashKeyField != nil { 1579 ok := object.Key("hashKeyField") 1580 ok.String(*v.HashKeyField) 1581 } 1582 1583 if v.HashKeyType != nil { 1584 ok := object.Key("hashKeyType") 1585 ok.String(*v.HashKeyType) 1586 } 1587 1588 if v.HashKeyValue != nil { 1589 ok := object.Key("hashKeyValue") 1590 ok.String(*v.HashKeyValue) 1591 } 1592 1593 if v.Operation != nil { 1594 ok := object.Key("operation") 1595 ok.String(*v.Operation) 1596 } 1597 1598 if v.Payload != nil { 1599 ok := object.Key("payload") 1600 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1601 return err 1602 } 1603 } 1604 1605 if v.PayloadField != nil { 1606 ok := object.Key("payloadField") 1607 ok.String(*v.PayloadField) 1608 } 1609 1610 if v.RangeKeyField != nil { 1611 ok := object.Key("rangeKeyField") 1612 ok.String(*v.RangeKeyField) 1613 } 1614 1615 if v.RangeKeyType != nil { 1616 ok := object.Key("rangeKeyType") 1617 ok.String(*v.RangeKeyType) 1618 } 1619 1620 if v.RangeKeyValue != nil { 1621 ok := object.Key("rangeKeyValue") 1622 ok.String(*v.RangeKeyValue) 1623 } 1624 1625 if v.TableName != nil { 1626 ok := object.Key("tableName") 1627 ok.String(*v.TableName) 1628 } 1629 1630 return nil 1631} 1632 1633func awsRestjson1_serializeDocumentDynamoDBv2Action(v *types.DynamoDBv2Action, value smithyjson.Value) error { 1634 object := value.Object() 1635 defer object.Close() 1636 1637 if v.Payload != nil { 1638 ok := object.Key("payload") 1639 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1640 return err 1641 } 1642 } 1643 1644 if v.TableName != nil { 1645 ok := object.Key("tableName") 1646 ok.String(*v.TableName) 1647 } 1648 1649 return nil 1650} 1651 1652func awsRestjson1_serializeDocumentEvent(v *types.Event, value smithyjson.Value) error { 1653 object := value.Object() 1654 defer object.Close() 1655 1656 if v.Actions != nil { 1657 ok := object.Key("actions") 1658 if err := awsRestjson1_serializeDocumentActions(v.Actions, ok); err != nil { 1659 return err 1660 } 1661 } 1662 1663 if v.Condition != nil { 1664 ok := object.Key("condition") 1665 ok.String(*v.Condition) 1666 } 1667 1668 if v.EventName != nil { 1669 ok := object.Key("eventName") 1670 ok.String(*v.EventName) 1671 } 1672 1673 return nil 1674} 1675 1676func awsRestjson1_serializeDocumentEvents(v []types.Event, value smithyjson.Value) error { 1677 array := value.Array() 1678 defer array.Close() 1679 1680 for i := range v { 1681 av := array.Value() 1682 if err := awsRestjson1_serializeDocumentEvent(&v[i], av); err != nil { 1683 return err 1684 } 1685 } 1686 return nil 1687} 1688 1689func awsRestjson1_serializeDocumentFirehoseAction(v *types.FirehoseAction, value smithyjson.Value) error { 1690 object := value.Object() 1691 defer object.Close() 1692 1693 if v.DeliveryStreamName != nil { 1694 ok := object.Key("deliveryStreamName") 1695 ok.String(*v.DeliveryStreamName) 1696 } 1697 1698 if v.Payload != nil { 1699 ok := object.Key("payload") 1700 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1701 return err 1702 } 1703 } 1704 1705 if v.Separator != nil { 1706 ok := object.Key("separator") 1707 ok.String(*v.Separator) 1708 } 1709 1710 return nil 1711} 1712 1713func awsRestjson1_serializeDocumentInputDefinition(v *types.InputDefinition, value smithyjson.Value) error { 1714 object := value.Object() 1715 defer object.Close() 1716 1717 if v.Attributes != nil { 1718 ok := object.Key("attributes") 1719 if err := awsRestjson1_serializeDocumentAttributes(v.Attributes, ok); err != nil { 1720 return err 1721 } 1722 } 1723 1724 return nil 1725} 1726 1727func awsRestjson1_serializeDocumentIotEventsAction(v *types.IotEventsAction, value smithyjson.Value) error { 1728 object := value.Object() 1729 defer object.Close() 1730 1731 if v.InputName != nil { 1732 ok := object.Key("inputName") 1733 ok.String(*v.InputName) 1734 } 1735 1736 if v.Payload != nil { 1737 ok := object.Key("payload") 1738 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1739 return err 1740 } 1741 } 1742 1743 return nil 1744} 1745 1746func awsRestjson1_serializeDocumentIotSiteWiseAction(v *types.IotSiteWiseAction, value smithyjson.Value) error { 1747 object := value.Object() 1748 defer object.Close() 1749 1750 if v.AssetId != nil { 1751 ok := object.Key("assetId") 1752 ok.String(*v.AssetId) 1753 } 1754 1755 if v.EntryId != nil { 1756 ok := object.Key("entryId") 1757 ok.String(*v.EntryId) 1758 } 1759 1760 if v.PropertyAlias != nil { 1761 ok := object.Key("propertyAlias") 1762 ok.String(*v.PropertyAlias) 1763 } 1764 1765 if v.PropertyId != nil { 1766 ok := object.Key("propertyId") 1767 ok.String(*v.PropertyId) 1768 } 1769 1770 if v.PropertyValue != nil { 1771 ok := object.Key("propertyValue") 1772 if err := awsRestjson1_serializeDocumentAssetPropertyValue(v.PropertyValue, ok); err != nil { 1773 return err 1774 } 1775 } 1776 1777 return nil 1778} 1779 1780func awsRestjson1_serializeDocumentIotTopicPublishAction(v *types.IotTopicPublishAction, value smithyjson.Value) error { 1781 object := value.Object() 1782 defer object.Close() 1783 1784 if v.MqttTopic != nil { 1785 ok := object.Key("mqttTopic") 1786 ok.String(*v.MqttTopic) 1787 } 1788 1789 if v.Payload != nil { 1790 ok := object.Key("payload") 1791 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1792 return err 1793 } 1794 } 1795 1796 return nil 1797} 1798 1799func awsRestjson1_serializeDocumentLambdaAction(v *types.LambdaAction, value smithyjson.Value) error { 1800 object := value.Object() 1801 defer object.Close() 1802 1803 if v.FunctionArn != nil { 1804 ok := object.Key("functionArn") 1805 ok.String(*v.FunctionArn) 1806 } 1807 1808 if v.Payload != nil { 1809 ok := object.Key("payload") 1810 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1811 return err 1812 } 1813 } 1814 1815 return nil 1816} 1817 1818func awsRestjson1_serializeDocumentLoggingOptions(v *types.LoggingOptions, value smithyjson.Value) error { 1819 object := value.Object() 1820 defer object.Close() 1821 1822 if v.DetectorDebugOptions != nil { 1823 ok := object.Key("detectorDebugOptions") 1824 if err := awsRestjson1_serializeDocumentDetectorDebugOptions(v.DetectorDebugOptions, ok); err != nil { 1825 return err 1826 } 1827 } 1828 1829 { 1830 ok := object.Key("enabled") 1831 ok.Boolean(v.Enabled) 1832 } 1833 1834 if len(v.Level) > 0 { 1835 ok := object.Key("level") 1836 ok.String(string(v.Level)) 1837 } 1838 1839 if v.RoleArn != nil { 1840 ok := object.Key("roleArn") 1841 ok.String(*v.RoleArn) 1842 } 1843 1844 return nil 1845} 1846 1847func awsRestjson1_serializeDocumentOnEnterLifecycle(v *types.OnEnterLifecycle, value smithyjson.Value) error { 1848 object := value.Object() 1849 defer object.Close() 1850 1851 if v.Events != nil { 1852 ok := object.Key("events") 1853 if err := awsRestjson1_serializeDocumentEvents(v.Events, ok); err != nil { 1854 return err 1855 } 1856 } 1857 1858 return nil 1859} 1860 1861func awsRestjson1_serializeDocumentOnExitLifecycle(v *types.OnExitLifecycle, value smithyjson.Value) error { 1862 object := value.Object() 1863 defer object.Close() 1864 1865 if v.Events != nil { 1866 ok := object.Key("events") 1867 if err := awsRestjson1_serializeDocumentEvents(v.Events, ok); err != nil { 1868 return err 1869 } 1870 } 1871 1872 return nil 1873} 1874 1875func awsRestjson1_serializeDocumentOnInputLifecycle(v *types.OnInputLifecycle, value smithyjson.Value) error { 1876 object := value.Object() 1877 defer object.Close() 1878 1879 if v.Events != nil { 1880 ok := object.Key("events") 1881 if err := awsRestjson1_serializeDocumentEvents(v.Events, ok); err != nil { 1882 return err 1883 } 1884 } 1885 1886 if v.TransitionEvents != nil { 1887 ok := object.Key("transitionEvents") 1888 if err := awsRestjson1_serializeDocumentTransitionEvents(v.TransitionEvents, ok); err != nil { 1889 return err 1890 } 1891 } 1892 1893 return nil 1894} 1895 1896func awsRestjson1_serializeDocumentPayload(v *types.Payload, value smithyjson.Value) error { 1897 object := value.Object() 1898 defer object.Close() 1899 1900 if v.ContentExpression != nil { 1901 ok := object.Key("contentExpression") 1902 ok.String(*v.ContentExpression) 1903 } 1904 1905 if len(v.Type) > 0 { 1906 ok := object.Key("type") 1907 ok.String(string(v.Type)) 1908 } 1909 1910 return nil 1911} 1912 1913func awsRestjson1_serializeDocumentResetTimerAction(v *types.ResetTimerAction, value smithyjson.Value) error { 1914 object := value.Object() 1915 defer object.Close() 1916 1917 if v.TimerName != nil { 1918 ok := object.Key("timerName") 1919 ok.String(*v.TimerName) 1920 } 1921 1922 return nil 1923} 1924 1925func awsRestjson1_serializeDocumentSetTimerAction(v *types.SetTimerAction, value smithyjson.Value) error { 1926 object := value.Object() 1927 defer object.Close() 1928 1929 if v.DurationExpression != nil { 1930 ok := object.Key("durationExpression") 1931 ok.String(*v.DurationExpression) 1932 } 1933 1934 if v.Seconds != nil { 1935 ok := object.Key("seconds") 1936 ok.Integer(*v.Seconds) 1937 } 1938 1939 if v.TimerName != nil { 1940 ok := object.Key("timerName") 1941 ok.String(*v.TimerName) 1942 } 1943 1944 return nil 1945} 1946 1947func awsRestjson1_serializeDocumentSetVariableAction(v *types.SetVariableAction, value smithyjson.Value) error { 1948 object := value.Object() 1949 defer object.Close() 1950 1951 if v.Value != nil { 1952 ok := object.Key("value") 1953 ok.String(*v.Value) 1954 } 1955 1956 if v.VariableName != nil { 1957 ok := object.Key("variableName") 1958 ok.String(*v.VariableName) 1959 } 1960 1961 return nil 1962} 1963 1964func awsRestjson1_serializeDocumentSNSTopicPublishAction(v *types.SNSTopicPublishAction, value smithyjson.Value) error { 1965 object := value.Object() 1966 defer object.Close() 1967 1968 if v.Payload != nil { 1969 ok := object.Key("payload") 1970 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1971 return err 1972 } 1973 } 1974 1975 if v.TargetArn != nil { 1976 ok := object.Key("targetArn") 1977 ok.String(*v.TargetArn) 1978 } 1979 1980 return nil 1981} 1982 1983func awsRestjson1_serializeDocumentSqsAction(v *types.SqsAction, value smithyjson.Value) error { 1984 object := value.Object() 1985 defer object.Close() 1986 1987 if v.Payload != nil { 1988 ok := object.Key("payload") 1989 if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil { 1990 return err 1991 } 1992 } 1993 1994 if v.QueueUrl != nil { 1995 ok := object.Key("queueUrl") 1996 ok.String(*v.QueueUrl) 1997 } 1998 1999 if v.UseBase64 != nil { 2000 ok := object.Key("useBase64") 2001 ok.Boolean(*v.UseBase64) 2002 } 2003 2004 return nil 2005} 2006 2007func awsRestjson1_serializeDocumentState(v *types.State, value smithyjson.Value) error { 2008 object := value.Object() 2009 defer object.Close() 2010 2011 if v.OnEnter != nil { 2012 ok := object.Key("onEnter") 2013 if err := awsRestjson1_serializeDocumentOnEnterLifecycle(v.OnEnter, ok); err != nil { 2014 return err 2015 } 2016 } 2017 2018 if v.OnExit != nil { 2019 ok := object.Key("onExit") 2020 if err := awsRestjson1_serializeDocumentOnExitLifecycle(v.OnExit, ok); err != nil { 2021 return err 2022 } 2023 } 2024 2025 if v.OnInput != nil { 2026 ok := object.Key("onInput") 2027 if err := awsRestjson1_serializeDocumentOnInputLifecycle(v.OnInput, ok); err != nil { 2028 return err 2029 } 2030 } 2031 2032 if v.StateName != nil { 2033 ok := object.Key("stateName") 2034 ok.String(*v.StateName) 2035 } 2036 2037 return nil 2038} 2039 2040func awsRestjson1_serializeDocumentStates(v []types.State, value smithyjson.Value) error { 2041 array := value.Array() 2042 defer array.Close() 2043 2044 for i := range v { 2045 av := array.Value() 2046 if err := awsRestjson1_serializeDocumentState(&v[i], av); err != nil { 2047 return err 2048 } 2049 } 2050 return nil 2051} 2052 2053func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 2054 object := value.Object() 2055 defer object.Close() 2056 2057 if v.Key != nil { 2058 ok := object.Key("key") 2059 ok.String(*v.Key) 2060 } 2061 2062 if v.Value != nil { 2063 ok := object.Key("value") 2064 ok.String(*v.Value) 2065 } 2066 2067 return nil 2068} 2069 2070func awsRestjson1_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error { 2071 array := value.Array() 2072 defer array.Close() 2073 2074 for i := range v { 2075 av := array.Value() 2076 if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil { 2077 return err 2078 } 2079 } 2080 return nil 2081} 2082 2083func awsRestjson1_serializeDocumentTransitionEvent(v *types.TransitionEvent, value smithyjson.Value) error { 2084 object := value.Object() 2085 defer object.Close() 2086 2087 if v.Actions != nil { 2088 ok := object.Key("actions") 2089 if err := awsRestjson1_serializeDocumentActions(v.Actions, ok); err != nil { 2090 return err 2091 } 2092 } 2093 2094 if v.Condition != nil { 2095 ok := object.Key("condition") 2096 ok.String(*v.Condition) 2097 } 2098 2099 if v.EventName != nil { 2100 ok := object.Key("eventName") 2101 ok.String(*v.EventName) 2102 } 2103 2104 if v.NextState != nil { 2105 ok := object.Key("nextState") 2106 ok.String(*v.NextState) 2107 } 2108 2109 return nil 2110} 2111 2112func awsRestjson1_serializeDocumentTransitionEvents(v []types.TransitionEvent, value smithyjson.Value) error { 2113 array := value.Array() 2114 defer array.Close() 2115 2116 for i := range v { 2117 av := array.Value() 2118 if err := awsRestjson1_serializeDocumentTransitionEvent(&v[i], av); err != nil { 2119 return err 2120 } 2121 } 2122 return nil 2123} 2124