1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. 2 3package kinesisvideo 4 5import ( 6 "time" 7 8 "github.com/aws/aws-sdk-go/aws" 9 "github.com/aws/aws-sdk-go/aws/awsutil" 10 "github.com/aws/aws-sdk-go/aws/request" 11) 12 13const opCreateStream = "CreateStream" 14 15// CreateStreamRequest generates a "aws/request.Request" representing the 16// client's request for the CreateStream operation. The "output" return 17// value will be populated with the request's response once the request completes 18// successfuly. 19// 20// Use "Send" method on the returned Request to send the API call to the service. 21// the "output" return value is not valid until after Send returns without error. 22// 23// See CreateStream for more information on using the CreateStream 24// API call, and error handling. 25// 26// This method is useful when you want to inject custom logic or configuration 27// into the SDK's request lifecycle. Such as custom headers, or retry logic. 28// 29// 30// // Example sending a request using the CreateStreamRequest method. 31// req, resp := client.CreateStreamRequest(params) 32// 33// err := req.Send() 34// if err == nil { // resp is now filled 35// fmt.Println(resp) 36// } 37// 38// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateStream 39func (c *KinesisVideo) CreateStreamRequest(input *CreateStreamInput) (req *request.Request, output *CreateStreamOutput) { 40 op := &request.Operation{ 41 Name: opCreateStream, 42 HTTPMethod: "POST", 43 HTTPPath: "/createStream", 44 } 45 46 if input == nil { 47 input = &CreateStreamInput{} 48 } 49 50 output = &CreateStreamOutput{} 51 req = c.newRequest(op, input, output) 52 return 53} 54 55// CreateStream API operation for Amazon Kinesis Video Streams. 56// 57// Creates a new Kinesis video stream. 58// 59// When you create a new stream, Kinesis Video Streams assigns it a version 60// number. When you change the stream's metadata, Kinesis Video Streams updates 61// the version. 62// 63// CreateStream is an asynchronous operation. 64// 65// For information about how the service works, see How it Works (http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/how-it-works.html). 66// 67// You must have permissions for the KinesisVideo:CreateStream action. 68// 69// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 70// with awserr.Error's Code and Message methods to get detailed information about 71// the error. 72// 73// See the AWS API reference guide for Amazon Kinesis Video Streams's 74// API operation CreateStream for usage and error information. 75// 76// Returned Error Codes: 77// * ErrCodeAccountStreamLimitExceededException "AccountStreamLimitExceededException" 78// The number of streams created for the account is too high. 79// 80// * ErrCodeDeviceStreamLimitExceededException "DeviceStreamLimitExceededException" 81// Not implemented. 82// 83// * ErrCodeResourceInUseException "ResourceInUseException" 84// The stream is currently not available for this operation. 85// 86// * ErrCodeInvalidDeviceException "InvalidDeviceException" 87// Not implemented. 88// 89// * ErrCodeInvalidArgumentException "InvalidArgumentException" 90// The value for this input parameter is invalid. 91// 92// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 93// Kinesis Video Streams has throttled the request because you have exceeded 94// the limit of allowed client calls. Try making the call later. 95// 96// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateStream 97func (c *KinesisVideo) CreateStream(input *CreateStreamInput) (*CreateStreamOutput, error) { 98 req, out := c.CreateStreamRequest(input) 99 return out, req.Send() 100} 101 102// CreateStreamWithContext is the same as CreateStream with the addition of 103// the ability to pass a context and additional request options. 104// 105// See CreateStream for details on how to use this API operation. 106// 107// The context must be non-nil and will be used for request cancellation. If 108// the context is nil a panic will occur. In the future the SDK may create 109// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 110// for more information on using Contexts. 111func (c *KinesisVideo) CreateStreamWithContext(ctx aws.Context, input *CreateStreamInput, opts ...request.Option) (*CreateStreamOutput, error) { 112 req, out := c.CreateStreamRequest(input) 113 req.SetContext(ctx) 114 req.ApplyOptions(opts...) 115 return out, req.Send() 116} 117 118const opDeleteStream = "DeleteStream" 119 120// DeleteStreamRequest generates a "aws/request.Request" representing the 121// client's request for the DeleteStream operation. The "output" return 122// value will be populated with the request's response once the request completes 123// successfuly. 124// 125// Use "Send" method on the returned Request to send the API call to the service. 126// the "output" return value is not valid until after Send returns without error. 127// 128// See DeleteStream for more information on using the DeleteStream 129// API call, and error handling. 130// 131// This method is useful when you want to inject custom logic or configuration 132// into the SDK's request lifecycle. Such as custom headers, or retry logic. 133// 134// 135// // Example sending a request using the DeleteStreamRequest method. 136// req, resp := client.DeleteStreamRequest(params) 137// 138// err := req.Send() 139// if err == nil { // resp is now filled 140// fmt.Println(resp) 141// } 142// 143// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteStream 144func (c *KinesisVideo) DeleteStreamRequest(input *DeleteStreamInput) (req *request.Request, output *DeleteStreamOutput) { 145 op := &request.Operation{ 146 Name: opDeleteStream, 147 HTTPMethod: "POST", 148 HTTPPath: "/deleteStream", 149 } 150 151 if input == nil { 152 input = &DeleteStreamInput{} 153 } 154 155 output = &DeleteStreamOutput{} 156 req = c.newRequest(op, input, output) 157 return 158} 159 160// DeleteStream API operation for Amazon Kinesis Video Streams. 161// 162// Deletes a Kinesis video stream and the data contained in the stream. 163// 164// This method marks the stream for deletion, and makes the data in the stream 165// inaccessible immediately. 166// 167// To ensure that you have the latest version of the stream before deleting 168// it, you can specify the stream version. Kinesis Video Streams assigns a version 169// to each stream. When you update a stream, Kinesis Video Streams assigns a 170// new version number. To get the latest stream version, use the DescribeStream 171// API. 172// 173// This operation requires permission for the KinesisVideo:DeleteStream action. 174// 175// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 176// with awserr.Error's Code and Message methods to get detailed information about 177// the error. 178// 179// See the AWS API reference guide for Amazon Kinesis Video Streams's 180// API operation DeleteStream for usage and error information. 181// 182// Returned Error Codes: 183// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 184// Kinesis Video Streams has throttled the request because you have exceeded 185// the limit of allowed client calls. Try making the call later. 186// 187// * ErrCodeInvalidArgumentException "InvalidArgumentException" 188// The value for this input parameter is invalid. 189// 190// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 191// Amazon Kinesis Video Streams can't find the stream that you specified. 192// 193// * ErrCodeNotAuthorizedException "NotAuthorizedException" 194// The caller is not authorized to perform this operation. 195// 196// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteStream 197func (c *KinesisVideo) DeleteStream(input *DeleteStreamInput) (*DeleteStreamOutput, error) { 198 req, out := c.DeleteStreamRequest(input) 199 return out, req.Send() 200} 201 202// DeleteStreamWithContext is the same as DeleteStream with the addition of 203// the ability to pass a context and additional request options. 204// 205// See DeleteStream for details on how to use this API operation. 206// 207// The context must be non-nil and will be used for request cancellation. If 208// the context is nil a panic will occur. In the future the SDK may create 209// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 210// for more information on using Contexts. 211func (c *KinesisVideo) DeleteStreamWithContext(ctx aws.Context, input *DeleteStreamInput, opts ...request.Option) (*DeleteStreamOutput, error) { 212 req, out := c.DeleteStreamRequest(input) 213 req.SetContext(ctx) 214 req.ApplyOptions(opts...) 215 return out, req.Send() 216} 217 218const opDescribeStream = "DescribeStream" 219 220// DescribeStreamRequest generates a "aws/request.Request" representing the 221// client's request for the DescribeStream operation. The "output" return 222// value will be populated with the request's response once the request completes 223// successfuly. 224// 225// Use "Send" method on the returned Request to send the API call to the service. 226// the "output" return value is not valid until after Send returns without error. 227// 228// See DescribeStream for more information on using the DescribeStream 229// API call, and error handling. 230// 231// This method is useful when you want to inject custom logic or configuration 232// into the SDK's request lifecycle. Such as custom headers, or retry logic. 233// 234// 235// // Example sending a request using the DescribeStreamRequest method. 236// req, resp := client.DescribeStreamRequest(params) 237// 238// err := req.Send() 239// if err == nil { // resp is now filled 240// fmt.Println(resp) 241// } 242// 243// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeStream 244func (c *KinesisVideo) DescribeStreamRequest(input *DescribeStreamInput) (req *request.Request, output *DescribeStreamOutput) { 245 op := &request.Operation{ 246 Name: opDescribeStream, 247 HTTPMethod: "POST", 248 HTTPPath: "/describeStream", 249 } 250 251 if input == nil { 252 input = &DescribeStreamInput{} 253 } 254 255 output = &DescribeStreamOutput{} 256 req = c.newRequest(op, input, output) 257 return 258} 259 260// DescribeStream API operation for Amazon Kinesis Video Streams. 261// 262// Returns the most current information about the specified stream. You must 263// specify either the StreamName or the StreamARN. 264// 265// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 266// with awserr.Error's Code and Message methods to get detailed information about 267// the error. 268// 269// See the AWS API reference guide for Amazon Kinesis Video Streams's 270// API operation DescribeStream for usage and error information. 271// 272// Returned Error Codes: 273// * ErrCodeInvalidArgumentException "InvalidArgumentException" 274// The value for this input parameter is invalid. 275// 276// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 277// Amazon Kinesis Video Streams can't find the stream that you specified. 278// 279// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 280// Kinesis Video Streams has throttled the request because you have exceeded 281// the limit of allowed client calls. Try making the call later. 282// 283// * ErrCodeNotAuthorizedException "NotAuthorizedException" 284// The caller is not authorized to perform this operation. 285// 286// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DescribeStream 287func (c *KinesisVideo) DescribeStream(input *DescribeStreamInput) (*DescribeStreamOutput, error) { 288 req, out := c.DescribeStreamRequest(input) 289 return out, req.Send() 290} 291 292// DescribeStreamWithContext is the same as DescribeStream with the addition of 293// the ability to pass a context and additional request options. 294// 295// See DescribeStream for details on how to use this API operation. 296// 297// The context must be non-nil and will be used for request cancellation. If 298// the context is nil a panic will occur. In the future the SDK may create 299// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 300// for more information on using Contexts. 301func (c *KinesisVideo) DescribeStreamWithContext(ctx aws.Context, input *DescribeStreamInput, opts ...request.Option) (*DescribeStreamOutput, error) { 302 req, out := c.DescribeStreamRequest(input) 303 req.SetContext(ctx) 304 req.ApplyOptions(opts...) 305 return out, req.Send() 306} 307 308const opGetDataEndpoint = "GetDataEndpoint" 309 310// GetDataEndpointRequest generates a "aws/request.Request" representing the 311// client's request for the GetDataEndpoint operation. The "output" return 312// value will be populated with the request's response once the request completes 313// successfuly. 314// 315// Use "Send" method on the returned Request to send the API call to the service. 316// the "output" return value is not valid until after Send returns without error. 317// 318// See GetDataEndpoint for more information on using the GetDataEndpoint 319// API call, and error handling. 320// 321// This method is useful when you want to inject custom logic or configuration 322// into the SDK's request lifecycle. Such as custom headers, or retry logic. 323// 324// 325// // Example sending a request using the GetDataEndpointRequest method. 326// req, resp := client.GetDataEndpointRequest(params) 327// 328// err := req.Send() 329// if err == nil { // resp is now filled 330// fmt.Println(resp) 331// } 332// 333// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetDataEndpoint 334func (c *KinesisVideo) GetDataEndpointRequest(input *GetDataEndpointInput) (req *request.Request, output *GetDataEndpointOutput) { 335 op := &request.Operation{ 336 Name: opGetDataEndpoint, 337 HTTPMethod: "POST", 338 HTTPPath: "/getDataEndpoint", 339 } 340 341 if input == nil { 342 input = &GetDataEndpointInput{} 343 } 344 345 output = &GetDataEndpointOutput{} 346 req = c.newRequest(op, input, output) 347 return 348} 349 350// GetDataEndpoint API operation for Amazon Kinesis Video Streams. 351// 352// Gets an endpoint for a specified stream for either reading or writing. Use 353// this endpoint in your application to read from the specified stream (using 354// the GetMedia or GetMediaForFragmentList operations) or write to it (using 355// the PutMedia operation). 356// 357// The returned endpoint does not have the API name appended. The client needs 358// to add the API name to the returned endpoint. 359// 360// In the request, specify the stream either by StreamName or StreamARN. 361// 362// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 363// with awserr.Error's Code and Message methods to get detailed information about 364// the error. 365// 366// See the AWS API reference guide for Amazon Kinesis Video Streams's 367// API operation GetDataEndpoint for usage and error information. 368// 369// Returned Error Codes: 370// * ErrCodeInvalidArgumentException "InvalidArgumentException" 371// The value for this input parameter is invalid. 372// 373// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 374// Amazon Kinesis Video Streams can't find the stream that you specified. 375// 376// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 377// Kinesis Video Streams has throttled the request because you have exceeded 378// the limit of allowed client calls. Try making the call later. 379// 380// * ErrCodeNotAuthorizedException "NotAuthorizedException" 381// The caller is not authorized to perform this operation. 382// 383// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/GetDataEndpoint 384func (c *KinesisVideo) GetDataEndpoint(input *GetDataEndpointInput) (*GetDataEndpointOutput, error) { 385 req, out := c.GetDataEndpointRequest(input) 386 return out, req.Send() 387} 388 389// GetDataEndpointWithContext is the same as GetDataEndpoint with the addition of 390// the ability to pass a context and additional request options. 391// 392// See GetDataEndpoint for details on how to use this API operation. 393// 394// The context must be non-nil and will be used for request cancellation. If 395// the context is nil a panic will occur. In the future the SDK may create 396// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 397// for more information on using Contexts. 398func (c *KinesisVideo) GetDataEndpointWithContext(ctx aws.Context, input *GetDataEndpointInput, opts ...request.Option) (*GetDataEndpointOutput, error) { 399 req, out := c.GetDataEndpointRequest(input) 400 req.SetContext(ctx) 401 req.ApplyOptions(opts...) 402 return out, req.Send() 403} 404 405const opListStreams = "ListStreams" 406 407// ListStreamsRequest generates a "aws/request.Request" representing the 408// client's request for the ListStreams operation. The "output" return 409// value will be populated with the request's response once the request completes 410// successfuly. 411// 412// Use "Send" method on the returned Request to send the API call to the service. 413// the "output" return value is not valid until after Send returns without error. 414// 415// See ListStreams for more information on using the ListStreams 416// API call, and error handling. 417// 418// This method is useful when you want to inject custom logic or configuration 419// into the SDK's request lifecycle. Such as custom headers, or retry logic. 420// 421// 422// // Example sending a request using the ListStreamsRequest method. 423// req, resp := client.ListStreamsRequest(params) 424// 425// err := req.Send() 426// if err == nil { // resp is now filled 427// fmt.Println(resp) 428// } 429// 430// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListStreams 431func (c *KinesisVideo) ListStreamsRequest(input *ListStreamsInput) (req *request.Request, output *ListStreamsOutput) { 432 op := &request.Operation{ 433 Name: opListStreams, 434 HTTPMethod: "POST", 435 HTTPPath: "/listStreams", 436 } 437 438 if input == nil { 439 input = &ListStreamsInput{} 440 } 441 442 output = &ListStreamsOutput{} 443 req = c.newRequest(op, input, output) 444 return 445} 446 447// ListStreams API operation for Amazon Kinesis Video Streams. 448// 449// Returns an array of StreamInfo objects. Each object describes a stream. To 450// retrieve only streams that satisfy a specific condition, you can specify 451// a StreamNameCondition. 452// 453// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 454// with awserr.Error's Code and Message methods to get detailed information about 455// the error. 456// 457// See the AWS API reference guide for Amazon Kinesis Video Streams's 458// API operation ListStreams for usage and error information. 459// 460// Returned Error Codes: 461// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 462// Kinesis Video Streams has throttled the request because you have exceeded 463// the limit of allowed client calls. Try making the call later. 464// 465// * ErrCodeInvalidArgumentException "InvalidArgumentException" 466// The value for this input parameter is invalid. 467// 468// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListStreams 469func (c *KinesisVideo) ListStreams(input *ListStreamsInput) (*ListStreamsOutput, error) { 470 req, out := c.ListStreamsRequest(input) 471 return out, req.Send() 472} 473 474// ListStreamsWithContext is the same as ListStreams with the addition of 475// the ability to pass a context and additional request options. 476// 477// See ListStreams for details on how to use this API operation. 478// 479// The context must be non-nil and will be used for request cancellation. If 480// the context is nil a panic will occur. In the future the SDK may create 481// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 482// for more information on using Contexts. 483func (c *KinesisVideo) ListStreamsWithContext(ctx aws.Context, input *ListStreamsInput, opts ...request.Option) (*ListStreamsOutput, error) { 484 req, out := c.ListStreamsRequest(input) 485 req.SetContext(ctx) 486 req.ApplyOptions(opts...) 487 return out, req.Send() 488} 489 490const opListTagsForStream = "ListTagsForStream" 491 492// ListTagsForStreamRequest generates a "aws/request.Request" representing the 493// client's request for the ListTagsForStream operation. The "output" return 494// value will be populated with the request's response once the request completes 495// successfuly. 496// 497// Use "Send" method on the returned Request to send the API call to the service. 498// the "output" return value is not valid until after Send returns without error. 499// 500// See ListTagsForStream for more information on using the ListTagsForStream 501// API call, and error handling. 502// 503// This method is useful when you want to inject custom logic or configuration 504// into the SDK's request lifecycle. Such as custom headers, or retry logic. 505// 506// 507// // Example sending a request using the ListTagsForStreamRequest method. 508// req, resp := client.ListTagsForStreamRequest(params) 509// 510// err := req.Send() 511// if err == nil { // resp is now filled 512// fmt.Println(resp) 513// } 514// 515// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListTagsForStream 516func (c *KinesisVideo) ListTagsForStreamRequest(input *ListTagsForStreamInput) (req *request.Request, output *ListTagsForStreamOutput) { 517 op := &request.Operation{ 518 Name: opListTagsForStream, 519 HTTPMethod: "POST", 520 HTTPPath: "/listTagsForStream", 521 } 522 523 if input == nil { 524 input = &ListTagsForStreamInput{} 525 } 526 527 output = &ListTagsForStreamOutput{} 528 req = c.newRequest(op, input, output) 529 return 530} 531 532// ListTagsForStream API operation for Amazon Kinesis Video Streams. 533// 534// Returns a list of tags associated with the specified stream. 535// 536// In the request, you must specify either the StreamName or the StreamARN. 537// 538// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 539// with awserr.Error's Code and Message methods to get detailed information about 540// the error. 541// 542// See the AWS API reference guide for Amazon Kinesis Video Streams's 543// API operation ListTagsForStream for usage and error information. 544// 545// Returned Error Codes: 546// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 547// Kinesis Video Streams has throttled the request because you have exceeded 548// the limit of allowed client calls. Try making the call later. 549// 550// * ErrCodeInvalidArgumentException "InvalidArgumentException" 551// The value for this input parameter is invalid. 552// 553// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 554// Amazon Kinesis Video Streams can't find the stream that you specified. 555// 556// * ErrCodeNotAuthorizedException "NotAuthorizedException" 557// The caller is not authorized to perform this operation. 558// 559// * ErrCodeInvalidResourceFormatException "InvalidResourceFormatException" 560// The format of the StreamARN is invalid. 561// 562// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/ListTagsForStream 563func (c *KinesisVideo) ListTagsForStream(input *ListTagsForStreamInput) (*ListTagsForStreamOutput, error) { 564 req, out := c.ListTagsForStreamRequest(input) 565 return out, req.Send() 566} 567 568// ListTagsForStreamWithContext is the same as ListTagsForStream with the addition of 569// the ability to pass a context and additional request options. 570// 571// See ListTagsForStream for details on how to use this API operation. 572// 573// The context must be non-nil and will be used for request cancellation. If 574// the context is nil a panic will occur. In the future the SDK may create 575// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 576// for more information on using Contexts. 577func (c *KinesisVideo) ListTagsForStreamWithContext(ctx aws.Context, input *ListTagsForStreamInput, opts ...request.Option) (*ListTagsForStreamOutput, error) { 578 req, out := c.ListTagsForStreamRequest(input) 579 req.SetContext(ctx) 580 req.ApplyOptions(opts...) 581 return out, req.Send() 582} 583 584const opTagStream = "TagStream" 585 586// TagStreamRequest generates a "aws/request.Request" representing the 587// client's request for the TagStream operation. The "output" return 588// value will be populated with the request's response once the request completes 589// successfuly. 590// 591// Use "Send" method on the returned Request to send the API call to the service. 592// the "output" return value is not valid until after Send returns without error. 593// 594// See TagStream for more information on using the TagStream 595// API call, and error handling. 596// 597// This method is useful when you want to inject custom logic or configuration 598// into the SDK's request lifecycle. Such as custom headers, or retry logic. 599// 600// 601// // Example sending a request using the TagStreamRequest method. 602// req, resp := client.TagStreamRequest(params) 603// 604// err := req.Send() 605// if err == nil { // resp is now filled 606// fmt.Println(resp) 607// } 608// 609// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/TagStream 610func (c *KinesisVideo) TagStreamRequest(input *TagStreamInput) (req *request.Request, output *TagStreamOutput) { 611 op := &request.Operation{ 612 Name: opTagStream, 613 HTTPMethod: "POST", 614 HTTPPath: "/tagStream", 615 } 616 617 if input == nil { 618 input = &TagStreamInput{} 619 } 620 621 output = &TagStreamOutput{} 622 req = c.newRequest(op, input, output) 623 return 624} 625 626// TagStream API operation for Amazon Kinesis Video Streams. 627// 628// Adds one or more tags to a stream. A tag is a key-value pair (the value is 629// optional) that you can define and assign to AWS resources. If you specify 630// a tag that already exists, the tag value is replaced with the value that 631// you specify in the request. For more information, see Using Cost Allocation 632// Tags (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html) 633// in the AWS Billing and Cost Management User Guide. 634// 635// You must provide either the StreamName or the StreamARN. 636// 637// This operation requires permission for the KinesisVideo:TagStream action. 638// 639// Kinesis video streams support up to 50 tags. 640// 641// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 642// with awserr.Error's Code and Message methods to get detailed information about 643// the error. 644// 645// See the AWS API reference guide for Amazon Kinesis Video Streams's 646// API operation TagStream for usage and error information. 647// 648// Returned Error Codes: 649// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 650// Kinesis Video Streams has throttled the request because you have exceeded 651// the limit of allowed client calls. Try making the call later. 652// 653// * ErrCodeInvalidArgumentException "InvalidArgumentException" 654// The value for this input parameter is invalid. 655// 656// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 657// Amazon Kinesis Video Streams can't find the stream that you specified. 658// 659// * ErrCodeNotAuthorizedException "NotAuthorizedException" 660// The caller is not authorized to perform this operation. 661// 662// * ErrCodeInvalidResourceFormatException "InvalidResourceFormatException" 663// The format of the StreamARN is invalid. 664// 665// * ErrCodeTagsPerResourceExceededLimitException "TagsPerResourceExceededLimitException" 666// You have exceeded the limit of tags that you can associate with the resource. 667// Kinesis video streams support up to 50 tags. 668// 669// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/TagStream 670func (c *KinesisVideo) TagStream(input *TagStreamInput) (*TagStreamOutput, error) { 671 req, out := c.TagStreamRequest(input) 672 return out, req.Send() 673} 674 675// TagStreamWithContext is the same as TagStream with the addition of 676// the ability to pass a context and additional request options. 677// 678// See TagStream for details on how to use this API operation. 679// 680// The context must be non-nil and will be used for request cancellation. If 681// the context is nil a panic will occur. In the future the SDK may create 682// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 683// for more information on using Contexts. 684func (c *KinesisVideo) TagStreamWithContext(ctx aws.Context, input *TagStreamInput, opts ...request.Option) (*TagStreamOutput, error) { 685 req, out := c.TagStreamRequest(input) 686 req.SetContext(ctx) 687 req.ApplyOptions(opts...) 688 return out, req.Send() 689} 690 691const opUntagStream = "UntagStream" 692 693// UntagStreamRequest generates a "aws/request.Request" representing the 694// client's request for the UntagStream operation. The "output" return 695// value will be populated with the request's response once the request completes 696// successfuly. 697// 698// Use "Send" method on the returned Request to send the API call to the service. 699// the "output" return value is not valid until after Send returns without error. 700// 701// See UntagStream for more information on using the UntagStream 702// API call, and error handling. 703// 704// This method is useful when you want to inject custom logic or configuration 705// into the SDK's request lifecycle. Such as custom headers, or retry logic. 706// 707// 708// // Example sending a request using the UntagStreamRequest method. 709// req, resp := client.UntagStreamRequest(params) 710// 711// err := req.Send() 712// if err == nil { // resp is now filled 713// fmt.Println(resp) 714// } 715// 716// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UntagStream 717func (c *KinesisVideo) UntagStreamRequest(input *UntagStreamInput) (req *request.Request, output *UntagStreamOutput) { 718 op := &request.Operation{ 719 Name: opUntagStream, 720 HTTPMethod: "POST", 721 HTTPPath: "/untagStream", 722 } 723 724 if input == nil { 725 input = &UntagStreamInput{} 726 } 727 728 output = &UntagStreamOutput{} 729 req = c.newRequest(op, input, output) 730 return 731} 732 733// UntagStream API operation for Amazon Kinesis Video Streams. 734// 735// Removes one or more tags from a stream. In the request, specify only a tag 736// key or keys; don't specify the value. If you specify a tag key that does 737// not exist, it's ignored. 738// 739// In the request, you must provide the StreamName or StreamARN. 740// 741// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 742// with awserr.Error's Code and Message methods to get detailed information about 743// the error. 744// 745// See the AWS API reference guide for Amazon Kinesis Video Streams's 746// API operation UntagStream for usage and error information. 747// 748// Returned Error Codes: 749// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 750// Kinesis Video Streams has throttled the request because you have exceeded 751// the limit of allowed client calls. Try making the call later. 752// 753// * ErrCodeInvalidArgumentException "InvalidArgumentException" 754// The value for this input parameter is invalid. 755// 756// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 757// Amazon Kinesis Video Streams can't find the stream that you specified. 758// 759// * ErrCodeNotAuthorizedException "NotAuthorizedException" 760// The caller is not authorized to perform this operation. 761// 762// * ErrCodeInvalidResourceFormatException "InvalidResourceFormatException" 763// The format of the StreamARN is invalid. 764// 765// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UntagStream 766func (c *KinesisVideo) UntagStream(input *UntagStreamInput) (*UntagStreamOutput, error) { 767 req, out := c.UntagStreamRequest(input) 768 return out, req.Send() 769} 770 771// UntagStreamWithContext is the same as UntagStream with the addition of 772// the ability to pass a context and additional request options. 773// 774// See UntagStream for details on how to use this API operation. 775// 776// The context must be non-nil and will be used for request cancellation. If 777// the context is nil a panic will occur. In the future the SDK may create 778// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 779// for more information on using Contexts. 780func (c *KinesisVideo) UntagStreamWithContext(ctx aws.Context, input *UntagStreamInput, opts ...request.Option) (*UntagStreamOutput, error) { 781 req, out := c.UntagStreamRequest(input) 782 req.SetContext(ctx) 783 req.ApplyOptions(opts...) 784 return out, req.Send() 785} 786 787const opUpdateDataRetention = "UpdateDataRetention" 788 789// UpdateDataRetentionRequest generates a "aws/request.Request" representing the 790// client's request for the UpdateDataRetention operation. The "output" return 791// value will be populated with the request's response once the request completes 792// successfuly. 793// 794// Use "Send" method on the returned Request to send the API call to the service. 795// the "output" return value is not valid until after Send returns without error. 796// 797// See UpdateDataRetention for more information on using the UpdateDataRetention 798// API call, and error handling. 799// 800// This method is useful when you want to inject custom logic or configuration 801// into the SDK's request lifecycle. Such as custom headers, or retry logic. 802// 803// 804// // Example sending a request using the UpdateDataRetentionRequest method. 805// req, resp := client.UpdateDataRetentionRequest(params) 806// 807// err := req.Send() 808// if err == nil { // resp is now filled 809// fmt.Println(resp) 810// } 811// 812// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateDataRetention 813func (c *KinesisVideo) UpdateDataRetentionRequest(input *UpdateDataRetentionInput) (req *request.Request, output *UpdateDataRetentionOutput) { 814 op := &request.Operation{ 815 Name: opUpdateDataRetention, 816 HTTPMethod: "POST", 817 HTTPPath: "/updateDataRetention", 818 } 819 820 if input == nil { 821 input = &UpdateDataRetentionInput{} 822 } 823 824 output = &UpdateDataRetentionOutput{} 825 req = c.newRequest(op, input, output) 826 return 827} 828 829// UpdateDataRetention API operation for Amazon Kinesis Video Streams. 830// 831// Increases or decreases the stream's data retention period by the value that 832// you specify. To indicate whether you want to increase or decrease the data 833// retention period, specify the Operation parameter in the request body. In 834// the request, you must specify either the StreamName or the StreamARN. 835// 836// The retention period that you specify replaces the current value. 837// 838// This operation requires permission for the KinesisVideo:UpdateDataRetention 839// action. 840// 841// Changing the data retention period affects the data in the stream as follows: 842// 843// * If the data retention period is increased, existing data is retained 844// for the new retention period. For example, if the data retention period 845// is increased from one hour to seven hours, all existing data is retained 846// for seven hours. 847// 848// * If the data retention period is decreased, existing data is retained 849// for the new retention period. For example, if the data retention period 850// is decreased from seven hours to one hour, all existing data is retained 851// for one hour, and any data older than one hour is deleted immediately. 852// 853// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 854// with awserr.Error's Code and Message methods to get detailed information about 855// the error. 856// 857// See the AWS API reference guide for Amazon Kinesis Video Streams's 858// API operation UpdateDataRetention for usage and error information. 859// 860// Returned Error Codes: 861// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 862// Kinesis Video Streams has throttled the request because you have exceeded 863// the limit of allowed client calls. Try making the call later. 864// 865// * ErrCodeInvalidArgumentException "InvalidArgumentException" 866// The value for this input parameter is invalid. 867// 868// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 869// Amazon Kinesis Video Streams can't find the stream that you specified. 870// 871// * ErrCodeResourceInUseException "ResourceInUseException" 872// The stream is currently not available for this operation. 873// 874// * ErrCodeNotAuthorizedException "NotAuthorizedException" 875// The caller is not authorized to perform this operation. 876// 877// * ErrCodeVersionMismatchException "VersionMismatchException" 878// The stream version that you specified is not the latest version. To get the 879// latest version, use the DescribeStream (http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_DescribeStream.html) 880// API. 881// 882// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateDataRetention 883func (c *KinesisVideo) UpdateDataRetention(input *UpdateDataRetentionInput) (*UpdateDataRetentionOutput, error) { 884 req, out := c.UpdateDataRetentionRequest(input) 885 return out, req.Send() 886} 887 888// UpdateDataRetentionWithContext is the same as UpdateDataRetention with the addition of 889// the ability to pass a context and additional request options. 890// 891// See UpdateDataRetention for details on how to use this API operation. 892// 893// The context must be non-nil and will be used for request cancellation. If 894// the context is nil a panic will occur. In the future the SDK may create 895// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 896// for more information on using Contexts. 897func (c *KinesisVideo) UpdateDataRetentionWithContext(ctx aws.Context, input *UpdateDataRetentionInput, opts ...request.Option) (*UpdateDataRetentionOutput, error) { 898 req, out := c.UpdateDataRetentionRequest(input) 899 req.SetContext(ctx) 900 req.ApplyOptions(opts...) 901 return out, req.Send() 902} 903 904const opUpdateStream = "UpdateStream" 905 906// UpdateStreamRequest generates a "aws/request.Request" representing the 907// client's request for the UpdateStream operation. The "output" return 908// value will be populated with the request's response once the request completes 909// successfuly. 910// 911// Use "Send" method on the returned Request to send the API call to the service. 912// the "output" return value is not valid until after Send returns without error. 913// 914// See UpdateStream for more information on using the UpdateStream 915// API call, and error handling. 916// 917// This method is useful when you want to inject custom logic or configuration 918// into the SDK's request lifecycle. Such as custom headers, or retry logic. 919// 920// 921// // Example sending a request using the UpdateStreamRequest method. 922// req, resp := client.UpdateStreamRequest(params) 923// 924// err := req.Send() 925// if err == nil { // resp is now filled 926// fmt.Println(resp) 927// } 928// 929// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateStream 930func (c *KinesisVideo) UpdateStreamRequest(input *UpdateStreamInput) (req *request.Request, output *UpdateStreamOutput) { 931 op := &request.Operation{ 932 Name: opUpdateStream, 933 HTTPMethod: "POST", 934 HTTPPath: "/updateStream", 935 } 936 937 if input == nil { 938 input = &UpdateStreamInput{} 939 } 940 941 output = &UpdateStreamOutput{} 942 req = c.newRequest(op, input, output) 943 return 944} 945 946// UpdateStream API operation for Amazon Kinesis Video Streams. 947// 948// Updates stream metadata, such as the device name and media type. 949// 950// You must provide the stream name or the Amazon Resource Name (ARN) of the 951// stream. 952// 953// To make sure that you have the latest version of the stream before updating 954// it, you can specify the stream version. Kinesis Video Streams assigns a version 955// to each stream. When you update a stream, Kinesis Video Streams assigns a 956// new version number. To get the latest stream version, use the DescribeStream 957// API. 958// 959// UpdateStream is an asynchronous operation, and takes time to complete. 960// 961// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 962// with awserr.Error's Code and Message methods to get detailed information about 963// the error. 964// 965// See the AWS API reference guide for Amazon Kinesis Video Streams's 966// API operation UpdateStream for usage and error information. 967// 968// Returned Error Codes: 969// * ErrCodeClientLimitExceededException "ClientLimitExceededException" 970// Kinesis Video Streams has throttled the request because you have exceeded 971// the limit of allowed client calls. Try making the call later. 972// 973// * ErrCodeInvalidArgumentException "InvalidArgumentException" 974// The value for this input parameter is invalid. 975// 976// * ErrCodeResourceNotFoundException "ResourceNotFoundException" 977// Amazon Kinesis Video Streams can't find the stream that you specified. 978// 979// * ErrCodeResourceInUseException "ResourceInUseException" 980// The stream is currently not available for this operation. 981// 982// * ErrCodeNotAuthorizedException "NotAuthorizedException" 983// The caller is not authorized to perform this operation. 984// 985// * ErrCodeVersionMismatchException "VersionMismatchException" 986// The stream version that you specified is not the latest version. To get the 987// latest version, use the DescribeStream (http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_DescribeStream.html) 988// API. 989// 990// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/UpdateStream 991func (c *KinesisVideo) UpdateStream(input *UpdateStreamInput) (*UpdateStreamOutput, error) { 992 req, out := c.UpdateStreamRequest(input) 993 return out, req.Send() 994} 995 996// UpdateStreamWithContext is the same as UpdateStream with the addition of 997// the ability to pass a context and additional request options. 998// 999// See UpdateStream for details on how to use this API operation. 1000// 1001// The context must be non-nil and will be used for request cancellation. If 1002// the context is nil a panic will occur. In the future the SDK may create 1003// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1004// for more information on using Contexts. 1005func (c *KinesisVideo) UpdateStreamWithContext(ctx aws.Context, input *UpdateStreamInput, opts ...request.Option) (*UpdateStreamOutput, error) { 1006 req, out := c.UpdateStreamRequest(input) 1007 req.SetContext(ctx) 1008 req.ApplyOptions(opts...) 1009 return out, req.Send() 1010} 1011 1012type CreateStreamInput struct { 1013 _ struct{} `type:"structure"` 1014 1015 // The number of hours that you want to retain the data in the stream. Kinesis 1016 // Video Streams retains the data in a data store that is associated with the 1017 // stream. 1018 // 1019 // The default value is 0, indicating that the stream does not persist data. 1020 // 1021 // When the DataRetentionInHours value is 0, consumers can still consume the 1022 // fragments that remain in the service host buffer, which has a retention time 1023 // limit of 5 minutes and a retention memory limit of 200 MB. Fragments are 1024 // removed from the buffer when either limit is reached. 1025 DataRetentionInHours *int64 `type:"integer"` 1026 1027 // The name of the device that is writing to the stream. 1028 // 1029 // In the current implementation, Kinesis Video Streams does not use this name. 1030 DeviceName *string `min:"1" type:"string"` 1031 1032 // The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis 1033 // Video Streams to use to encrypt stream data. 1034 // 1035 // If no key ID is specified, the default, Kinesis Video-managed key (aws/kinesisvideo) 1036 // is used. 1037 // 1038 // For more information, see DescribeKey (http://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters). 1039 KmsKeyId *string `min:"1" type:"string"` 1040 1041 // The media type of the stream. Consumers of the stream can use this information 1042 // when processing the stream. For more information about media types, see Media 1043 // Types (http://www.iana.org/assignments/media-types/media-types.xhtml). If 1044 // you choose to specify the MediaType, see Naming Requirements (https://tools.ietf.org/html/rfc6838#section-4.2) 1045 // for guidelines. 1046 // 1047 // To play video on the console, the media must be H.264 encoded, and you need 1048 // to specify this video type in this parameter as video/h264. 1049 // 1050 // This parameter is optional; the default value is null (or empty in JSON). 1051 MediaType *string `min:"1" type:"string"` 1052 1053 // A name for the stream that you are creating. 1054 // 1055 // The stream name is an identifier for the stream, and must be unique for each 1056 // account and region. 1057 // 1058 // StreamName is a required field 1059 StreamName *string `min:"1" type:"string" required:"true"` 1060} 1061 1062// String returns the string representation 1063func (s CreateStreamInput) String() string { 1064 return awsutil.Prettify(s) 1065} 1066 1067// GoString returns the string representation 1068func (s CreateStreamInput) GoString() string { 1069 return s.String() 1070} 1071 1072// Validate inspects the fields of the type to determine if they are valid. 1073func (s *CreateStreamInput) Validate() error { 1074 invalidParams := request.ErrInvalidParams{Context: "CreateStreamInput"} 1075 if s.DeviceName != nil && len(*s.DeviceName) < 1 { 1076 invalidParams.Add(request.NewErrParamMinLen("DeviceName", 1)) 1077 } 1078 if s.KmsKeyId != nil && len(*s.KmsKeyId) < 1 { 1079 invalidParams.Add(request.NewErrParamMinLen("KmsKeyId", 1)) 1080 } 1081 if s.MediaType != nil && len(*s.MediaType) < 1 { 1082 invalidParams.Add(request.NewErrParamMinLen("MediaType", 1)) 1083 } 1084 if s.StreamName == nil { 1085 invalidParams.Add(request.NewErrParamRequired("StreamName")) 1086 } 1087 if s.StreamName != nil && len(*s.StreamName) < 1 { 1088 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 1089 } 1090 1091 if invalidParams.Len() > 0 { 1092 return invalidParams 1093 } 1094 return nil 1095} 1096 1097// SetDataRetentionInHours sets the DataRetentionInHours field's value. 1098func (s *CreateStreamInput) SetDataRetentionInHours(v int64) *CreateStreamInput { 1099 s.DataRetentionInHours = &v 1100 return s 1101} 1102 1103// SetDeviceName sets the DeviceName field's value. 1104func (s *CreateStreamInput) SetDeviceName(v string) *CreateStreamInput { 1105 s.DeviceName = &v 1106 return s 1107} 1108 1109// SetKmsKeyId sets the KmsKeyId field's value. 1110func (s *CreateStreamInput) SetKmsKeyId(v string) *CreateStreamInput { 1111 s.KmsKeyId = &v 1112 return s 1113} 1114 1115// SetMediaType sets the MediaType field's value. 1116func (s *CreateStreamInput) SetMediaType(v string) *CreateStreamInput { 1117 s.MediaType = &v 1118 return s 1119} 1120 1121// SetStreamName sets the StreamName field's value. 1122func (s *CreateStreamInput) SetStreamName(v string) *CreateStreamInput { 1123 s.StreamName = &v 1124 return s 1125} 1126 1127type CreateStreamOutput struct { 1128 _ struct{} `type:"structure"` 1129 1130 // The Amazon Resource Name (ARN) of the stream. 1131 StreamARN *string `min:"1" type:"string"` 1132} 1133 1134// String returns the string representation 1135func (s CreateStreamOutput) String() string { 1136 return awsutil.Prettify(s) 1137} 1138 1139// GoString returns the string representation 1140func (s CreateStreamOutput) GoString() string { 1141 return s.String() 1142} 1143 1144// SetStreamARN sets the StreamARN field's value. 1145func (s *CreateStreamOutput) SetStreamARN(v string) *CreateStreamOutput { 1146 s.StreamARN = &v 1147 return s 1148} 1149 1150type DeleteStreamInput struct { 1151 _ struct{} `type:"structure"` 1152 1153 // Optional: The version of the stream that you want to delete. 1154 // 1155 // Specify the version as a safeguard to ensure that your are deleting the correct 1156 // stream. To get the stream version, use the DescribeStream API. 1157 // 1158 // If not specified, only the CreationTime is checked before deleting the stream. 1159 CurrentVersion *string `min:"1" type:"string"` 1160 1161 // The Amazon Resource Name (ARN) of the stream that you want to delete. 1162 // 1163 // StreamARN is a required field 1164 StreamARN *string `min:"1" type:"string" required:"true"` 1165} 1166 1167// String returns the string representation 1168func (s DeleteStreamInput) String() string { 1169 return awsutil.Prettify(s) 1170} 1171 1172// GoString returns the string representation 1173func (s DeleteStreamInput) GoString() string { 1174 return s.String() 1175} 1176 1177// Validate inspects the fields of the type to determine if they are valid. 1178func (s *DeleteStreamInput) Validate() error { 1179 invalidParams := request.ErrInvalidParams{Context: "DeleteStreamInput"} 1180 if s.CurrentVersion != nil && len(*s.CurrentVersion) < 1 { 1181 invalidParams.Add(request.NewErrParamMinLen("CurrentVersion", 1)) 1182 } 1183 if s.StreamARN == nil { 1184 invalidParams.Add(request.NewErrParamRequired("StreamARN")) 1185 } 1186 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 1187 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 1188 } 1189 1190 if invalidParams.Len() > 0 { 1191 return invalidParams 1192 } 1193 return nil 1194} 1195 1196// SetCurrentVersion sets the CurrentVersion field's value. 1197func (s *DeleteStreamInput) SetCurrentVersion(v string) *DeleteStreamInput { 1198 s.CurrentVersion = &v 1199 return s 1200} 1201 1202// SetStreamARN sets the StreamARN field's value. 1203func (s *DeleteStreamInput) SetStreamARN(v string) *DeleteStreamInput { 1204 s.StreamARN = &v 1205 return s 1206} 1207 1208type DeleteStreamOutput struct { 1209 _ struct{} `type:"structure"` 1210} 1211 1212// String returns the string representation 1213func (s DeleteStreamOutput) String() string { 1214 return awsutil.Prettify(s) 1215} 1216 1217// GoString returns the string representation 1218func (s DeleteStreamOutput) GoString() string { 1219 return s.String() 1220} 1221 1222type DescribeStreamInput struct { 1223 _ struct{} `type:"structure"` 1224 1225 // The Amazon Resource Name (ARN) of the stream. 1226 StreamARN *string `min:"1" type:"string"` 1227 1228 // The name of the stream. 1229 StreamName *string `min:"1" type:"string"` 1230} 1231 1232// String returns the string representation 1233func (s DescribeStreamInput) String() string { 1234 return awsutil.Prettify(s) 1235} 1236 1237// GoString returns the string representation 1238func (s DescribeStreamInput) GoString() string { 1239 return s.String() 1240} 1241 1242// Validate inspects the fields of the type to determine if they are valid. 1243func (s *DescribeStreamInput) Validate() error { 1244 invalidParams := request.ErrInvalidParams{Context: "DescribeStreamInput"} 1245 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 1246 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 1247 } 1248 if s.StreamName != nil && len(*s.StreamName) < 1 { 1249 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 1250 } 1251 1252 if invalidParams.Len() > 0 { 1253 return invalidParams 1254 } 1255 return nil 1256} 1257 1258// SetStreamARN sets the StreamARN field's value. 1259func (s *DescribeStreamInput) SetStreamARN(v string) *DescribeStreamInput { 1260 s.StreamARN = &v 1261 return s 1262} 1263 1264// SetStreamName sets the StreamName field's value. 1265func (s *DescribeStreamInput) SetStreamName(v string) *DescribeStreamInput { 1266 s.StreamName = &v 1267 return s 1268} 1269 1270type DescribeStreamOutput struct { 1271 _ struct{} `type:"structure"` 1272 1273 // An object that describes the stream. 1274 StreamInfo *StreamInfo `type:"structure"` 1275} 1276 1277// String returns the string representation 1278func (s DescribeStreamOutput) String() string { 1279 return awsutil.Prettify(s) 1280} 1281 1282// GoString returns the string representation 1283func (s DescribeStreamOutput) GoString() string { 1284 return s.String() 1285} 1286 1287// SetStreamInfo sets the StreamInfo field's value. 1288func (s *DescribeStreamOutput) SetStreamInfo(v *StreamInfo) *DescribeStreamOutput { 1289 s.StreamInfo = v 1290 return s 1291} 1292 1293type GetDataEndpointInput struct { 1294 _ struct{} `type:"structure"` 1295 1296 // The name of the API action for which to get an endpoint. 1297 // 1298 // APIName is a required field 1299 APIName *string `type:"string" required:"true" enum:"APIName"` 1300 1301 // The Amazon Resource Name (ARN) of the stream that you want to get the endpoint 1302 // for. You must specify either this parameter or a StreamName in the request. 1303 StreamARN *string `min:"1" type:"string"` 1304 1305 // The name of the stream that you want to get the endpoint for. You must specify 1306 // either this parameter or a StreamARN in the request. 1307 StreamName *string `min:"1" type:"string"` 1308} 1309 1310// String returns the string representation 1311func (s GetDataEndpointInput) String() string { 1312 return awsutil.Prettify(s) 1313} 1314 1315// GoString returns the string representation 1316func (s GetDataEndpointInput) GoString() string { 1317 return s.String() 1318} 1319 1320// Validate inspects the fields of the type to determine if they are valid. 1321func (s *GetDataEndpointInput) Validate() error { 1322 invalidParams := request.ErrInvalidParams{Context: "GetDataEndpointInput"} 1323 if s.APIName == nil { 1324 invalidParams.Add(request.NewErrParamRequired("APIName")) 1325 } 1326 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 1327 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 1328 } 1329 if s.StreamName != nil && len(*s.StreamName) < 1 { 1330 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 1331 } 1332 1333 if invalidParams.Len() > 0 { 1334 return invalidParams 1335 } 1336 return nil 1337} 1338 1339// SetAPIName sets the APIName field's value. 1340func (s *GetDataEndpointInput) SetAPIName(v string) *GetDataEndpointInput { 1341 s.APIName = &v 1342 return s 1343} 1344 1345// SetStreamARN sets the StreamARN field's value. 1346func (s *GetDataEndpointInput) SetStreamARN(v string) *GetDataEndpointInput { 1347 s.StreamARN = &v 1348 return s 1349} 1350 1351// SetStreamName sets the StreamName field's value. 1352func (s *GetDataEndpointInput) SetStreamName(v string) *GetDataEndpointInput { 1353 s.StreamName = &v 1354 return s 1355} 1356 1357type GetDataEndpointOutput struct { 1358 _ struct{} `type:"structure"` 1359 1360 // The endpoint value. To read data from the stream or to write data to it, 1361 // specify this endpoint in your application. 1362 DataEndpoint *string `type:"string"` 1363} 1364 1365// String returns the string representation 1366func (s GetDataEndpointOutput) String() string { 1367 return awsutil.Prettify(s) 1368} 1369 1370// GoString returns the string representation 1371func (s GetDataEndpointOutput) GoString() string { 1372 return s.String() 1373} 1374 1375// SetDataEndpoint sets the DataEndpoint field's value. 1376func (s *GetDataEndpointOutput) SetDataEndpoint(v string) *GetDataEndpointOutput { 1377 s.DataEndpoint = &v 1378 return s 1379} 1380 1381type ListStreamsInput struct { 1382 _ struct{} `type:"structure"` 1383 1384 // The maximum number of streams to return in the response. The default is 10,000. 1385 MaxResults *int64 `min:"1" type:"integer"` 1386 1387 // If you specify this parameter, when the result of a ListStreams operation 1388 // is truncated, the call returns the NextToken in the response. To get another 1389 // batch of streams, provide this token in your next request. 1390 NextToken *string `type:"string"` 1391 1392 // Optional: Returns only streams that satisfy a specific condition. Currently, 1393 // you can specify only the prefix of a stream name as a condition. 1394 StreamNameCondition *StreamNameCondition `type:"structure"` 1395} 1396 1397// String returns the string representation 1398func (s ListStreamsInput) String() string { 1399 return awsutil.Prettify(s) 1400} 1401 1402// GoString returns the string representation 1403func (s ListStreamsInput) GoString() string { 1404 return s.String() 1405} 1406 1407// Validate inspects the fields of the type to determine if they are valid. 1408func (s *ListStreamsInput) Validate() error { 1409 invalidParams := request.ErrInvalidParams{Context: "ListStreamsInput"} 1410 if s.MaxResults != nil && *s.MaxResults < 1 { 1411 invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) 1412 } 1413 if s.StreamNameCondition != nil { 1414 if err := s.StreamNameCondition.Validate(); err != nil { 1415 invalidParams.AddNested("StreamNameCondition", err.(request.ErrInvalidParams)) 1416 } 1417 } 1418 1419 if invalidParams.Len() > 0 { 1420 return invalidParams 1421 } 1422 return nil 1423} 1424 1425// SetMaxResults sets the MaxResults field's value. 1426func (s *ListStreamsInput) SetMaxResults(v int64) *ListStreamsInput { 1427 s.MaxResults = &v 1428 return s 1429} 1430 1431// SetNextToken sets the NextToken field's value. 1432func (s *ListStreamsInput) SetNextToken(v string) *ListStreamsInput { 1433 s.NextToken = &v 1434 return s 1435} 1436 1437// SetStreamNameCondition sets the StreamNameCondition field's value. 1438func (s *ListStreamsInput) SetStreamNameCondition(v *StreamNameCondition) *ListStreamsInput { 1439 s.StreamNameCondition = v 1440 return s 1441} 1442 1443type ListStreamsOutput struct { 1444 _ struct{} `type:"structure"` 1445 1446 // If the response is truncated, the call returns this element with a token. 1447 // To get the next batch of streams, use this token in your next request. 1448 NextToken *string `type:"string"` 1449 1450 // An array of StreamInfo objects. 1451 StreamInfoList []*StreamInfo `type:"list"` 1452} 1453 1454// String returns the string representation 1455func (s ListStreamsOutput) String() string { 1456 return awsutil.Prettify(s) 1457} 1458 1459// GoString returns the string representation 1460func (s ListStreamsOutput) GoString() string { 1461 return s.String() 1462} 1463 1464// SetNextToken sets the NextToken field's value. 1465func (s *ListStreamsOutput) SetNextToken(v string) *ListStreamsOutput { 1466 s.NextToken = &v 1467 return s 1468} 1469 1470// SetStreamInfoList sets the StreamInfoList field's value. 1471func (s *ListStreamsOutput) SetStreamInfoList(v []*StreamInfo) *ListStreamsOutput { 1472 s.StreamInfoList = v 1473 return s 1474} 1475 1476type ListTagsForStreamInput struct { 1477 _ struct{} `type:"structure"` 1478 1479 // If you specify this parameter and the result of a ListTagsForStream call 1480 // is truncated, the response includes a token that you can use in the next 1481 // request to fetch the next batch of tags. 1482 NextToken *string `type:"string"` 1483 1484 // The Amazon Resource Name (ARN) of the stream that you want to list tags for. 1485 StreamARN *string `min:"1" type:"string"` 1486 1487 // The name of the stream that you want to list tags for. 1488 StreamName *string `min:"1" type:"string"` 1489} 1490 1491// String returns the string representation 1492func (s ListTagsForStreamInput) String() string { 1493 return awsutil.Prettify(s) 1494} 1495 1496// GoString returns the string representation 1497func (s ListTagsForStreamInput) GoString() string { 1498 return s.String() 1499} 1500 1501// Validate inspects the fields of the type to determine if they are valid. 1502func (s *ListTagsForStreamInput) Validate() error { 1503 invalidParams := request.ErrInvalidParams{Context: "ListTagsForStreamInput"} 1504 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 1505 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 1506 } 1507 if s.StreamName != nil && len(*s.StreamName) < 1 { 1508 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 1509 } 1510 1511 if invalidParams.Len() > 0 { 1512 return invalidParams 1513 } 1514 return nil 1515} 1516 1517// SetNextToken sets the NextToken field's value. 1518func (s *ListTagsForStreamInput) SetNextToken(v string) *ListTagsForStreamInput { 1519 s.NextToken = &v 1520 return s 1521} 1522 1523// SetStreamARN sets the StreamARN field's value. 1524func (s *ListTagsForStreamInput) SetStreamARN(v string) *ListTagsForStreamInput { 1525 s.StreamARN = &v 1526 return s 1527} 1528 1529// SetStreamName sets the StreamName field's value. 1530func (s *ListTagsForStreamInput) SetStreamName(v string) *ListTagsForStreamInput { 1531 s.StreamName = &v 1532 return s 1533} 1534 1535type ListTagsForStreamOutput struct { 1536 _ struct{} `type:"structure"` 1537 1538 // If you specify this parameter and the result of a ListTags call is truncated, 1539 // the response includes a token that you can use in the next request to fetch 1540 // the next set of tags. 1541 NextToken *string `type:"string"` 1542 1543 // A map of tag keys and values associated with the specified stream. 1544 Tags map[string]*string `min:"1" type:"map"` 1545} 1546 1547// String returns the string representation 1548func (s ListTagsForStreamOutput) String() string { 1549 return awsutil.Prettify(s) 1550} 1551 1552// GoString returns the string representation 1553func (s ListTagsForStreamOutput) GoString() string { 1554 return s.String() 1555} 1556 1557// SetNextToken sets the NextToken field's value. 1558func (s *ListTagsForStreamOutput) SetNextToken(v string) *ListTagsForStreamOutput { 1559 s.NextToken = &v 1560 return s 1561} 1562 1563// SetTags sets the Tags field's value. 1564func (s *ListTagsForStreamOutput) SetTags(v map[string]*string) *ListTagsForStreamOutput { 1565 s.Tags = v 1566 return s 1567} 1568 1569// An object describing a Kinesis video stream. 1570type StreamInfo struct { 1571 _ struct{} `type:"structure"` 1572 1573 // A time stamp that indicates when the stream was created. 1574 CreationTime *time.Time `type:"timestamp"` 1575 1576 // How long the stream retains data, in hours. 1577 DataRetentionInHours *int64 `type:"integer"` 1578 1579 // The name of the device that is associated with the stream. 1580 DeviceName *string `min:"1" type:"string"` 1581 1582 // The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video 1583 // Streams uses to encrypt data on the stream. 1584 KmsKeyId *string `min:"1" type:"string"` 1585 1586 // The MediaType of the stream. 1587 MediaType *string `min:"1" type:"string"` 1588 1589 // The status of the stream. 1590 Status *string `type:"string" enum:"Status"` 1591 1592 // The Amazon Resource Name (ARN) of the stream. 1593 StreamARN *string `min:"1" type:"string"` 1594 1595 // The name of the stream. 1596 StreamName *string `min:"1" type:"string"` 1597 1598 // The version of the stream. 1599 Version *string `min:"1" type:"string"` 1600} 1601 1602// String returns the string representation 1603func (s StreamInfo) String() string { 1604 return awsutil.Prettify(s) 1605} 1606 1607// GoString returns the string representation 1608func (s StreamInfo) GoString() string { 1609 return s.String() 1610} 1611 1612// SetCreationTime sets the CreationTime field's value. 1613func (s *StreamInfo) SetCreationTime(v time.Time) *StreamInfo { 1614 s.CreationTime = &v 1615 return s 1616} 1617 1618// SetDataRetentionInHours sets the DataRetentionInHours field's value. 1619func (s *StreamInfo) SetDataRetentionInHours(v int64) *StreamInfo { 1620 s.DataRetentionInHours = &v 1621 return s 1622} 1623 1624// SetDeviceName sets the DeviceName field's value. 1625func (s *StreamInfo) SetDeviceName(v string) *StreamInfo { 1626 s.DeviceName = &v 1627 return s 1628} 1629 1630// SetKmsKeyId sets the KmsKeyId field's value. 1631func (s *StreamInfo) SetKmsKeyId(v string) *StreamInfo { 1632 s.KmsKeyId = &v 1633 return s 1634} 1635 1636// SetMediaType sets the MediaType field's value. 1637func (s *StreamInfo) SetMediaType(v string) *StreamInfo { 1638 s.MediaType = &v 1639 return s 1640} 1641 1642// SetStatus sets the Status field's value. 1643func (s *StreamInfo) SetStatus(v string) *StreamInfo { 1644 s.Status = &v 1645 return s 1646} 1647 1648// SetStreamARN sets the StreamARN field's value. 1649func (s *StreamInfo) SetStreamARN(v string) *StreamInfo { 1650 s.StreamARN = &v 1651 return s 1652} 1653 1654// SetStreamName sets the StreamName field's value. 1655func (s *StreamInfo) SetStreamName(v string) *StreamInfo { 1656 s.StreamName = &v 1657 return s 1658} 1659 1660// SetVersion sets the Version field's value. 1661func (s *StreamInfo) SetVersion(v string) *StreamInfo { 1662 s.Version = &v 1663 return s 1664} 1665 1666// Specifies the condition that streams must satisfy to be returned when you 1667// list streams (see the ListStreams API). A condition has a comparison operation 1668// and a value. Currently, you can specify only the BEGINS_WITH operator, which 1669// finds streams whose names start with a given prefix. 1670type StreamNameCondition struct { 1671 _ struct{} `type:"structure"` 1672 1673 // A comparison operator. Currently, you can specify only the BEGINS_WITH operator, 1674 // which finds streams whose names start with a given prefix. 1675 ComparisonOperator *string `type:"string" enum:"ComparisonOperator"` 1676 1677 // A value to compare. 1678 ComparisonValue *string `min:"1" type:"string"` 1679} 1680 1681// String returns the string representation 1682func (s StreamNameCondition) String() string { 1683 return awsutil.Prettify(s) 1684} 1685 1686// GoString returns the string representation 1687func (s StreamNameCondition) GoString() string { 1688 return s.String() 1689} 1690 1691// Validate inspects the fields of the type to determine if they are valid. 1692func (s *StreamNameCondition) Validate() error { 1693 invalidParams := request.ErrInvalidParams{Context: "StreamNameCondition"} 1694 if s.ComparisonValue != nil && len(*s.ComparisonValue) < 1 { 1695 invalidParams.Add(request.NewErrParamMinLen("ComparisonValue", 1)) 1696 } 1697 1698 if invalidParams.Len() > 0 { 1699 return invalidParams 1700 } 1701 return nil 1702} 1703 1704// SetComparisonOperator sets the ComparisonOperator field's value. 1705func (s *StreamNameCondition) SetComparisonOperator(v string) *StreamNameCondition { 1706 s.ComparisonOperator = &v 1707 return s 1708} 1709 1710// SetComparisonValue sets the ComparisonValue field's value. 1711func (s *StreamNameCondition) SetComparisonValue(v string) *StreamNameCondition { 1712 s.ComparisonValue = &v 1713 return s 1714} 1715 1716type TagStreamInput struct { 1717 _ struct{} `type:"structure"` 1718 1719 // The Amazon Resource Name (ARN) of the resource that you want to add the tag 1720 // or tags to. 1721 StreamARN *string `min:"1" type:"string"` 1722 1723 // The name of the stream that you want to add the tag or tags to. 1724 StreamName *string `min:"1" type:"string"` 1725 1726 // A list of tags to associate with the specified stream. Each tag is a key-value 1727 // pair (the value is optional). 1728 // 1729 // Tags is a required field 1730 Tags map[string]*string `min:"1" type:"map" required:"true"` 1731} 1732 1733// String returns the string representation 1734func (s TagStreamInput) String() string { 1735 return awsutil.Prettify(s) 1736} 1737 1738// GoString returns the string representation 1739func (s TagStreamInput) GoString() string { 1740 return s.String() 1741} 1742 1743// Validate inspects the fields of the type to determine if they are valid. 1744func (s *TagStreamInput) Validate() error { 1745 invalidParams := request.ErrInvalidParams{Context: "TagStreamInput"} 1746 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 1747 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 1748 } 1749 if s.StreamName != nil && len(*s.StreamName) < 1 { 1750 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 1751 } 1752 if s.Tags == nil { 1753 invalidParams.Add(request.NewErrParamRequired("Tags")) 1754 } 1755 if s.Tags != nil && len(s.Tags) < 1 { 1756 invalidParams.Add(request.NewErrParamMinLen("Tags", 1)) 1757 } 1758 1759 if invalidParams.Len() > 0 { 1760 return invalidParams 1761 } 1762 return nil 1763} 1764 1765// SetStreamARN sets the StreamARN field's value. 1766func (s *TagStreamInput) SetStreamARN(v string) *TagStreamInput { 1767 s.StreamARN = &v 1768 return s 1769} 1770 1771// SetStreamName sets the StreamName field's value. 1772func (s *TagStreamInput) SetStreamName(v string) *TagStreamInput { 1773 s.StreamName = &v 1774 return s 1775} 1776 1777// SetTags sets the Tags field's value. 1778func (s *TagStreamInput) SetTags(v map[string]*string) *TagStreamInput { 1779 s.Tags = v 1780 return s 1781} 1782 1783type TagStreamOutput struct { 1784 _ struct{} `type:"structure"` 1785} 1786 1787// String returns the string representation 1788func (s TagStreamOutput) String() string { 1789 return awsutil.Prettify(s) 1790} 1791 1792// GoString returns the string representation 1793func (s TagStreamOutput) GoString() string { 1794 return s.String() 1795} 1796 1797type UntagStreamInput struct { 1798 _ struct{} `type:"structure"` 1799 1800 // The Amazon Resource Name (ARN) of the stream that you want to remove tags 1801 // from. 1802 StreamARN *string `min:"1" type:"string"` 1803 1804 // The name of the stream that you want to remove tags from. 1805 StreamName *string `min:"1" type:"string"` 1806 1807 // A list of the keys of the tags that you want to remove. 1808 // 1809 // TagKeyList is a required field 1810 TagKeyList []*string `min:"1" type:"list" required:"true"` 1811} 1812 1813// String returns the string representation 1814func (s UntagStreamInput) String() string { 1815 return awsutil.Prettify(s) 1816} 1817 1818// GoString returns the string representation 1819func (s UntagStreamInput) GoString() string { 1820 return s.String() 1821} 1822 1823// Validate inspects the fields of the type to determine if they are valid. 1824func (s *UntagStreamInput) Validate() error { 1825 invalidParams := request.ErrInvalidParams{Context: "UntagStreamInput"} 1826 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 1827 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 1828 } 1829 if s.StreamName != nil && len(*s.StreamName) < 1 { 1830 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 1831 } 1832 if s.TagKeyList == nil { 1833 invalidParams.Add(request.NewErrParamRequired("TagKeyList")) 1834 } 1835 if s.TagKeyList != nil && len(s.TagKeyList) < 1 { 1836 invalidParams.Add(request.NewErrParamMinLen("TagKeyList", 1)) 1837 } 1838 1839 if invalidParams.Len() > 0 { 1840 return invalidParams 1841 } 1842 return nil 1843} 1844 1845// SetStreamARN sets the StreamARN field's value. 1846func (s *UntagStreamInput) SetStreamARN(v string) *UntagStreamInput { 1847 s.StreamARN = &v 1848 return s 1849} 1850 1851// SetStreamName sets the StreamName field's value. 1852func (s *UntagStreamInput) SetStreamName(v string) *UntagStreamInput { 1853 s.StreamName = &v 1854 return s 1855} 1856 1857// SetTagKeyList sets the TagKeyList field's value. 1858func (s *UntagStreamInput) SetTagKeyList(v []*string) *UntagStreamInput { 1859 s.TagKeyList = v 1860 return s 1861} 1862 1863type UntagStreamOutput struct { 1864 _ struct{} `type:"structure"` 1865} 1866 1867// String returns the string representation 1868func (s UntagStreamOutput) String() string { 1869 return awsutil.Prettify(s) 1870} 1871 1872// GoString returns the string representation 1873func (s UntagStreamOutput) GoString() string { 1874 return s.String() 1875} 1876 1877type UpdateDataRetentionInput struct { 1878 _ struct{} `type:"structure"` 1879 1880 // The version of the stream whose retention period you want to change. To get 1881 // the version, call either the DescribeStream or the ListStreams API. 1882 // 1883 // CurrentVersion is a required field 1884 CurrentVersion *string `min:"1" type:"string" required:"true"` 1885 1886 // The retention period, in hours. The value you specify replaces the current 1887 // value. 1888 // 1889 // DataRetentionChangeInHours is a required field 1890 DataRetentionChangeInHours *int64 `min:"1" type:"integer" required:"true"` 1891 1892 // Indicates whether you want to increase or decrease the retention period. 1893 // 1894 // Operation is a required field 1895 Operation *string `type:"string" required:"true" enum:"UpdateDataRetentionOperation"` 1896 1897 // The Amazon Resource Name (ARN) of the stream whose retention period you want 1898 // to change. 1899 StreamARN *string `min:"1" type:"string"` 1900 1901 // The name of the stream whose retention period you want to change. 1902 StreamName *string `min:"1" type:"string"` 1903} 1904 1905// String returns the string representation 1906func (s UpdateDataRetentionInput) String() string { 1907 return awsutil.Prettify(s) 1908} 1909 1910// GoString returns the string representation 1911func (s UpdateDataRetentionInput) GoString() string { 1912 return s.String() 1913} 1914 1915// Validate inspects the fields of the type to determine if they are valid. 1916func (s *UpdateDataRetentionInput) Validate() error { 1917 invalidParams := request.ErrInvalidParams{Context: "UpdateDataRetentionInput"} 1918 if s.CurrentVersion == nil { 1919 invalidParams.Add(request.NewErrParamRequired("CurrentVersion")) 1920 } 1921 if s.CurrentVersion != nil && len(*s.CurrentVersion) < 1 { 1922 invalidParams.Add(request.NewErrParamMinLen("CurrentVersion", 1)) 1923 } 1924 if s.DataRetentionChangeInHours == nil { 1925 invalidParams.Add(request.NewErrParamRequired("DataRetentionChangeInHours")) 1926 } 1927 if s.DataRetentionChangeInHours != nil && *s.DataRetentionChangeInHours < 1 { 1928 invalidParams.Add(request.NewErrParamMinValue("DataRetentionChangeInHours", 1)) 1929 } 1930 if s.Operation == nil { 1931 invalidParams.Add(request.NewErrParamRequired("Operation")) 1932 } 1933 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 1934 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 1935 } 1936 if s.StreamName != nil && len(*s.StreamName) < 1 { 1937 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 1938 } 1939 1940 if invalidParams.Len() > 0 { 1941 return invalidParams 1942 } 1943 return nil 1944} 1945 1946// SetCurrentVersion sets the CurrentVersion field's value. 1947func (s *UpdateDataRetentionInput) SetCurrentVersion(v string) *UpdateDataRetentionInput { 1948 s.CurrentVersion = &v 1949 return s 1950} 1951 1952// SetDataRetentionChangeInHours sets the DataRetentionChangeInHours field's value. 1953func (s *UpdateDataRetentionInput) SetDataRetentionChangeInHours(v int64) *UpdateDataRetentionInput { 1954 s.DataRetentionChangeInHours = &v 1955 return s 1956} 1957 1958// SetOperation sets the Operation field's value. 1959func (s *UpdateDataRetentionInput) SetOperation(v string) *UpdateDataRetentionInput { 1960 s.Operation = &v 1961 return s 1962} 1963 1964// SetStreamARN sets the StreamARN field's value. 1965func (s *UpdateDataRetentionInput) SetStreamARN(v string) *UpdateDataRetentionInput { 1966 s.StreamARN = &v 1967 return s 1968} 1969 1970// SetStreamName sets the StreamName field's value. 1971func (s *UpdateDataRetentionInput) SetStreamName(v string) *UpdateDataRetentionInput { 1972 s.StreamName = &v 1973 return s 1974} 1975 1976type UpdateDataRetentionOutput struct { 1977 _ struct{} `type:"structure"` 1978} 1979 1980// String returns the string representation 1981func (s UpdateDataRetentionOutput) String() string { 1982 return awsutil.Prettify(s) 1983} 1984 1985// GoString returns the string representation 1986func (s UpdateDataRetentionOutput) GoString() string { 1987 return s.String() 1988} 1989 1990type UpdateStreamInput struct { 1991 _ struct{} `type:"structure"` 1992 1993 // The version of the stream whose metadata you want to update. 1994 // 1995 // CurrentVersion is a required field 1996 CurrentVersion *string `min:"1" type:"string" required:"true"` 1997 1998 // The name of the device that is writing to the stream. 1999 // 2000 // In the current implementation, Kinesis Video Streams does not use this name. 2001 DeviceName *string `min:"1" type:"string"` 2002 2003 // The stream's media type. Use MediaType to specify the type of content that 2004 // the stream contains to the consumers of the stream. For more information 2005 // about media types, see Media Types (http://www.iana.org/assignments/media-types/media-types.xhtml). 2006 // If you choose to specify the MediaType, see Naming Requirements (https://tools.ietf.org/html/rfc6838#section-4.2). 2007 // 2008 // To play video on the console, you must specify the correct video type. For 2009 // example, if the video in the stream is H.264, specify video/h264 as the MediaType. 2010 MediaType *string `min:"1" type:"string"` 2011 2012 // The ARN of the stream whose metadata you want to update. 2013 StreamARN *string `min:"1" type:"string"` 2014 2015 // The name of the stream whose metadata you want to update. 2016 // 2017 // The stream name is an identifier for the stream, and must be unique for each 2018 // account and region. 2019 StreamName *string `min:"1" type:"string"` 2020} 2021 2022// String returns the string representation 2023func (s UpdateStreamInput) String() string { 2024 return awsutil.Prettify(s) 2025} 2026 2027// GoString returns the string representation 2028func (s UpdateStreamInput) GoString() string { 2029 return s.String() 2030} 2031 2032// Validate inspects the fields of the type to determine if they are valid. 2033func (s *UpdateStreamInput) Validate() error { 2034 invalidParams := request.ErrInvalidParams{Context: "UpdateStreamInput"} 2035 if s.CurrentVersion == nil { 2036 invalidParams.Add(request.NewErrParamRequired("CurrentVersion")) 2037 } 2038 if s.CurrentVersion != nil && len(*s.CurrentVersion) < 1 { 2039 invalidParams.Add(request.NewErrParamMinLen("CurrentVersion", 1)) 2040 } 2041 if s.DeviceName != nil && len(*s.DeviceName) < 1 { 2042 invalidParams.Add(request.NewErrParamMinLen("DeviceName", 1)) 2043 } 2044 if s.MediaType != nil && len(*s.MediaType) < 1 { 2045 invalidParams.Add(request.NewErrParamMinLen("MediaType", 1)) 2046 } 2047 if s.StreamARN != nil && len(*s.StreamARN) < 1 { 2048 invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) 2049 } 2050 if s.StreamName != nil && len(*s.StreamName) < 1 { 2051 invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) 2052 } 2053 2054 if invalidParams.Len() > 0 { 2055 return invalidParams 2056 } 2057 return nil 2058} 2059 2060// SetCurrentVersion sets the CurrentVersion field's value. 2061func (s *UpdateStreamInput) SetCurrentVersion(v string) *UpdateStreamInput { 2062 s.CurrentVersion = &v 2063 return s 2064} 2065 2066// SetDeviceName sets the DeviceName field's value. 2067func (s *UpdateStreamInput) SetDeviceName(v string) *UpdateStreamInput { 2068 s.DeviceName = &v 2069 return s 2070} 2071 2072// SetMediaType sets the MediaType field's value. 2073func (s *UpdateStreamInput) SetMediaType(v string) *UpdateStreamInput { 2074 s.MediaType = &v 2075 return s 2076} 2077 2078// SetStreamARN sets the StreamARN field's value. 2079func (s *UpdateStreamInput) SetStreamARN(v string) *UpdateStreamInput { 2080 s.StreamARN = &v 2081 return s 2082} 2083 2084// SetStreamName sets the StreamName field's value. 2085func (s *UpdateStreamInput) SetStreamName(v string) *UpdateStreamInput { 2086 s.StreamName = &v 2087 return s 2088} 2089 2090type UpdateStreamOutput struct { 2091 _ struct{} `type:"structure"` 2092} 2093 2094// String returns the string representation 2095func (s UpdateStreamOutput) String() string { 2096 return awsutil.Prettify(s) 2097} 2098 2099// GoString returns the string representation 2100func (s UpdateStreamOutput) GoString() string { 2101 return s.String() 2102} 2103 2104const ( 2105 // APINamePutMedia is a APIName enum value 2106 APINamePutMedia = "PUT_MEDIA" 2107 2108 // APINameGetMedia is a APIName enum value 2109 APINameGetMedia = "GET_MEDIA" 2110 2111 // APINameListFragments is a APIName enum value 2112 APINameListFragments = "LIST_FRAGMENTS" 2113 2114 // APINameGetMediaForFragmentList is a APIName enum value 2115 APINameGetMediaForFragmentList = "GET_MEDIA_FOR_FRAGMENT_LIST" 2116 2117 // APINameGetHlsStreamingSessionUrl is a APIName enum value 2118 APINameGetHlsStreamingSessionUrl = "GET_HLS_STREAMING_SESSION_URL" 2119) 2120 2121const ( 2122 // ComparisonOperatorBeginsWith is a ComparisonOperator enum value 2123 ComparisonOperatorBeginsWith = "BEGINS_WITH" 2124) 2125 2126const ( 2127 // StatusCreating is a Status enum value 2128 StatusCreating = "CREATING" 2129 2130 // StatusActive is a Status enum value 2131 StatusActive = "ACTIVE" 2132 2133 // StatusUpdating is a Status enum value 2134 StatusUpdating = "UPDATING" 2135 2136 // StatusDeleting is a Status enum value 2137 StatusDeleting = "DELETING" 2138) 2139 2140const ( 2141 // UpdateDataRetentionOperationIncreaseDataRetention is a UpdateDataRetentionOperation enum value 2142 UpdateDataRetentionOperationIncreaseDataRetention = "INCREASE_DATA_RETENTION" 2143 2144 // UpdateDataRetentionOperationDecreaseDataRetention is a UpdateDataRetentionOperation enum value 2145 UpdateDataRetentionOperationDecreaseDataRetention = "DECREASE_DATA_RETENTION" 2146) 2147