/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the kinesis-2013-12-02.normal.json service model. */ using System; using System.Collections.Generic; using Amazon.Runtime; using Amazon.Kinesis.Model; namespace Amazon.Kinesis { /// /// Interface for accessing Kinesis /// /// Amazon Kinesis Data Streams Service API Reference /// /// Amazon Kinesis Data Streams is a managed service that scales elastically for real-time /// processing of streaming big data. /// /// public partial interface IAmazonKinesis : IAmazonService, IDisposable { #if BCL45 || AWS_ASYNC_ENUMERABLES_API /// /// Paginators for the service /// IKinesisPaginatorFactory Paginators { get; } #endif #region AddTagsToStream /// /// Adds or updates tags for the specified Kinesis data stream. You can assign up to 50 /// tags to a data stream. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// If tags have already been assigned to the stream, AddTagsToStream overwrites /// any existing tags that correspond to the specified tag keys. /// /// /// /// AddTagsToStream has a limit of five transactions per second per account. /// /// /// Container for the necessary parameters to execute the AddTagsToStream service method. /// /// The response from the AddTagsToStream service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for AddTagsToStream Operation AddTagsToStreamResponse AddTagsToStream(AddTagsToStreamRequest request); /// /// Initiates the asynchronous execution of the AddTagsToStream operation. /// /// /// Container for the necessary parameters to execute the AddTagsToStream operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAddTagsToStream /// operation. /// REST API Reference for AddTagsToStream Operation IAsyncResult BeginAddTagsToStream(AddTagsToStreamRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the AddTagsToStream operation. /// /// /// The IAsyncResult returned by the call to BeginAddTagsToStream. /// /// Returns a AddTagsToStreamResult from Kinesis. /// REST API Reference for AddTagsToStream Operation AddTagsToStreamResponse EndAddTagsToStream(IAsyncResult asyncResult); #endregion #region CreateStream /// /// Creates a Kinesis data stream. A stream captures and transports data records that /// are continuously emitted from different data sources or producers. Scale-out /// within a stream is explicitly supported by means of shards, which are uniquely identified /// groups of data records in a stream. /// /// /// /// You can create your data stream using either on-demand or provisioned capacity mode. /// Data streams with an on-demand mode require no capacity planning and automatically /// scale to handle gigabytes of write and read throughput per minute. With the on-demand /// mode, Kinesis Data Streams automatically manages the shards in order to provide the /// necessary throughput. For the data streams with a provisioned mode, you must specify /// the number of shards for the data stream. Each shard can support reads up to five /// transactions per second, up to a maximum data read total of 2 MiB per second. Each /// shard can support writes up to 1,000 records per second, up to a maximum data write /// total of 1 MiB per second. If the amount of data input increases or decreases, you /// can add or remove shards. /// /// /// /// The stream name identifies the stream. The name is scoped to the Amazon Web Services /// account used by the application. It is also scoped by Amazon Web Services Region. /// That is, two streams in two different accounts can have the same name, and two streams /// in the same account, but in two different Regions, can have the same name. /// /// /// /// CreateStream is an asynchronous operation. Upon receiving a CreateStream /// request, Kinesis Data Streams immediately returns and sets the stream status to CREATING. /// After the stream is created, Kinesis Data Streams sets the stream status to ACTIVE. /// You should perform read and write operations only on an ACTIVE stream. /// /// /// /// /// You receive a LimitExceededException when making a CreateStream /// request when you try to do one of the following: /// /// /// /// For the default shard limit for an Amazon Web Services account, see Amazon /// Kinesis Data Streams Limits in the Amazon Kinesis Data Streams Developer Guide. /// To increase this limit, contact /// Amazon Web Services Support. /// /// /// /// You can use DescribeStreamSummary to check the stream status, which is returned /// in StreamStatus. /// /// /// /// CreateStream has a limit of five transactions per second per account. /// /// /// Container for the necessary parameters to execute the CreateStream service method. /// /// The response from the CreateStream service method, as returned by Kinesis. /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// REST API Reference for CreateStream Operation CreateStreamResponse CreateStream(CreateStreamRequest request); /// /// Initiates the asynchronous execution of the CreateStream operation. /// /// /// Container for the necessary parameters to execute the CreateStream operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateStream /// operation. /// REST API Reference for CreateStream Operation IAsyncResult BeginCreateStream(CreateStreamRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the CreateStream operation. /// /// /// The IAsyncResult returned by the call to BeginCreateStream. /// /// Returns a CreateStreamResult from Kinesis. /// REST API Reference for CreateStream Operation CreateStreamResponse EndCreateStream(IAsyncResult asyncResult); #endregion #region DecreaseStreamRetentionPeriod /// /// Decreases the Kinesis data stream's retention period, which is the length of time /// data records are accessible after they are added to the stream. The minimum value /// of a stream's retention period is 24 hours. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// This operation may result in lost data. For example, if the stream's retention period /// is 48 hours and is decreased to 24 hours, any data already in the stream that is older /// than 24 hours is inaccessible. /// /// /// The name of the stream to modify. /// The new retention period of the stream, in hours. Must be less than the current retention period. /// /// The response from the DecreaseStreamRetentionPeriod service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DecreaseStreamRetentionPeriod Operation DecreaseStreamRetentionPeriodResponse DecreaseStreamRetentionPeriod(string streamName, int retentionPeriodHours); /// /// Decreases the Kinesis data stream's retention period, which is the length of time /// data records are accessible after they are added to the stream. The minimum value /// of a stream's retention period is 24 hours. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// This operation may result in lost data. For example, if the stream's retention period /// is 48 hours and is decreased to 24 hours, any data already in the stream that is older /// than 24 hours is inaccessible. /// /// /// Container for the necessary parameters to execute the DecreaseStreamRetentionPeriod service method. /// /// The response from the DecreaseStreamRetentionPeriod service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DecreaseStreamRetentionPeriod Operation DecreaseStreamRetentionPeriodResponse DecreaseStreamRetentionPeriod(DecreaseStreamRetentionPeriodRequest request); /// /// Initiates the asynchronous execution of the DecreaseStreamRetentionPeriod operation. /// /// /// Container for the necessary parameters to execute the DecreaseStreamRetentionPeriod operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDecreaseStreamRetentionPeriod /// operation. /// REST API Reference for DecreaseStreamRetentionPeriod Operation IAsyncResult BeginDecreaseStreamRetentionPeriod(DecreaseStreamRetentionPeriodRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DecreaseStreamRetentionPeriod operation. /// /// /// The IAsyncResult returned by the call to BeginDecreaseStreamRetentionPeriod. /// /// Returns a DecreaseStreamRetentionPeriodResult from Kinesis. /// REST API Reference for DecreaseStreamRetentionPeriod Operation DecreaseStreamRetentionPeriodResponse EndDecreaseStreamRetentionPeriod(IAsyncResult asyncResult); #endregion #region DeleteStream /// /// Deletes a Kinesis data stream and all its shards and data. You must shut down any /// applications that are operating on the stream before you delete the stream. If an /// application attempts to operate on a deleted stream, it receives the exception ResourceNotFoundException. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// If the stream is in the ACTIVE state, you can delete it. After a DeleteStream /// request, the specified stream is in the DELETING state until Kinesis /// Data Streams completes the deletion. /// /// /// /// Note: Kinesis Data Streams might continue to accept data read and write operations, /// such as PutRecord, PutRecords, and GetRecords, on a stream in /// the DELETING state until the stream deletion is complete. /// /// /// /// When you delete a stream, any shards in that stream are also deleted, and any tags /// are dissociated from the stream. /// /// /// /// You can use the DescribeStreamSummary operation to check the state of the stream, /// which is returned in StreamStatus. /// /// /// /// DeleteStream has a limit of five transactions per second per account. /// /// /// Container for the necessary parameters to execute the DeleteStream service method. /// /// The response from the DeleteStream service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DeleteStream Operation DeleteStreamResponse DeleteStream(DeleteStreamRequest request); /// /// Initiates the asynchronous execution of the DeleteStream operation. /// /// /// Container for the necessary parameters to execute the DeleteStream operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteStream /// operation. /// REST API Reference for DeleteStream Operation IAsyncResult BeginDeleteStream(DeleteStreamRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeleteStream operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteStream. /// /// Returns a DeleteStreamResult from Kinesis. /// REST API Reference for DeleteStream Operation DeleteStreamResponse EndDeleteStream(IAsyncResult asyncResult); #endregion #region DeregisterStreamConsumer /// /// To deregister a consumer, provide its ARN. Alternatively, you can provide the ARN /// of the data stream and the name you gave the consumer when you registered it. You /// may also provide all three parameters, as long as they don't conflict with each other. /// If you don't know the name or ARN of the consumer that you want to deregister, you /// can use the ListStreamConsumers operation to get a list of the descriptions /// of all the consumers that are currently registered with a given data stream. The description /// of a consumer contains its name and ARN. /// /// /// /// This operation has a limit of five transactions per second per stream. /// /// /// Container for the necessary parameters to execute the DeregisterStreamConsumer service method. /// /// The response from the DeregisterStreamConsumer service method, as returned by Kinesis. /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DeregisterStreamConsumer Operation DeregisterStreamConsumerResponse DeregisterStreamConsumer(DeregisterStreamConsumerRequest request); /// /// Initiates the asynchronous execution of the DeregisterStreamConsumer operation. /// /// /// Container for the necessary parameters to execute the DeregisterStreamConsumer operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterStreamConsumer /// operation. /// REST API Reference for DeregisterStreamConsumer Operation IAsyncResult BeginDeregisterStreamConsumer(DeregisterStreamConsumerRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DeregisterStreamConsumer operation. /// /// /// The IAsyncResult returned by the call to BeginDeregisterStreamConsumer. /// /// Returns a DeregisterStreamConsumerResult from Kinesis. /// REST API Reference for DeregisterStreamConsumer Operation DeregisterStreamConsumerResponse EndDeregisterStreamConsumer(IAsyncResult asyncResult); #endregion #region DescribeLimits /// /// Describes the shard limits and usage for the account. /// /// /// /// If you update your account limits, the old limits might be returned for a few minutes. /// /// /// /// This operation has a limit of one transaction per second per account. /// /// /// Container for the necessary parameters to execute the DescribeLimits service method. /// /// The response from the DescribeLimits service method, as returned by Kinesis. /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// REST API Reference for DescribeLimits Operation DescribeLimitsResponse DescribeLimits(DescribeLimitsRequest request); /// /// Initiates the asynchronous execution of the DescribeLimits operation. /// /// /// Container for the necessary parameters to execute the DescribeLimits operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLimits /// operation. /// REST API Reference for DescribeLimits Operation IAsyncResult BeginDescribeLimits(DescribeLimitsRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DescribeLimits operation. /// /// /// The IAsyncResult returned by the call to BeginDescribeLimits. /// /// Returns a DescribeLimitsResult from Kinesis. /// REST API Reference for DescribeLimits Operation DescribeLimitsResponse EndDescribeLimits(IAsyncResult asyncResult); #endregion #region DescribeStream /// /// Describes the specified Kinesis data stream. /// /// /// /// This API has been revised. It's highly recommended that you use the DescribeStreamSummary /// API to get a summarized description of the specified Kinesis data stream and the ListShards /// API to list the shards in a specified data stream and obtain information about each /// shard. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// The information returned includes the stream name, Amazon Resource Name (ARN), creation /// time, enhanced metric configuration, and shard map. The shard map is an array of shard /// objects. For each shard object, there is the hash key and sequence number ranges that /// the shard spans, and the IDs of any earlier shards that played in a role in creating /// the shard. Every record ingested in the stream is identified by a sequence number, /// which is assigned when the record is put into the stream. /// /// /// /// You can limit the number of shards returned by each call. For more information, see /// Retrieving /// Shards from a Stream in the Amazon Kinesis Data Streams Developer Guide. /// /// /// /// There are no guarantees about the chronological order shards returned. To process /// shards in chronological order, use the ID of the parent shard to track the lineage /// to the oldest shard. /// /// /// /// This operation has a limit of 10 transactions per second per account. /// /// /// Container for the necessary parameters to execute the DescribeStream service method. /// /// The response from the DescribeStream service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DescribeStream Operation DescribeStreamResponse DescribeStream(DescribeStreamRequest request); /// /// Initiates the asynchronous execution of the DescribeStream operation. /// /// /// Container for the necessary parameters to execute the DescribeStream operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStream /// operation. /// REST API Reference for DescribeStream Operation IAsyncResult BeginDescribeStream(DescribeStreamRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DescribeStream operation. /// /// /// The IAsyncResult returned by the call to BeginDescribeStream. /// /// Returns a DescribeStreamResult from Kinesis. /// REST API Reference for DescribeStream Operation DescribeStreamResponse EndDescribeStream(IAsyncResult asyncResult); #endregion #region DescribeStreamConsumer /// /// To get the description of a registered consumer, provide the ARN of the consumer. /// Alternatively, you can provide the ARN of the data stream and the name you gave the /// consumer when you registered it. You may also provide all three parameters, as long /// as they don't conflict with each other. If you don't know the name or ARN of the consumer /// that you want to describe, you can use the ListStreamConsumers operation to /// get a list of the descriptions of all the consumers that are currently registered /// with a given data stream. /// /// /// /// This operation has a limit of 20 transactions per second per stream. /// /// /// Container for the necessary parameters to execute the DescribeStreamConsumer service method. /// /// The response from the DescribeStreamConsumer service method, as returned by Kinesis. /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DescribeStreamConsumer Operation DescribeStreamConsumerResponse DescribeStreamConsumer(DescribeStreamConsumerRequest request); /// /// Initiates the asynchronous execution of the DescribeStreamConsumer operation. /// /// /// Container for the necessary parameters to execute the DescribeStreamConsumer operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStreamConsumer /// operation. /// REST API Reference for DescribeStreamConsumer Operation IAsyncResult BeginDescribeStreamConsumer(DescribeStreamConsumerRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DescribeStreamConsumer operation. /// /// /// The IAsyncResult returned by the call to BeginDescribeStreamConsumer. /// /// Returns a DescribeStreamConsumerResult from Kinesis. /// REST API Reference for DescribeStreamConsumer Operation DescribeStreamConsumerResponse EndDescribeStreamConsumer(IAsyncResult asyncResult); #endregion #region DescribeStreamSummary /// /// Provides a summarized description of the specified Kinesis data stream without the /// shard list. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// The information returned includes the stream name, Amazon Resource Name (ARN), status, /// record retention period, approximate creation time, monitoring, encryption details, /// and open shard count. /// /// /// /// DescribeStreamSummary has a limit of 20 transactions per second per account. /// /// /// Container for the necessary parameters to execute the DescribeStreamSummary service method. /// /// The response from the DescribeStreamSummary service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DescribeStreamSummary Operation DescribeStreamSummaryResponse DescribeStreamSummary(DescribeStreamSummaryRequest request); /// /// Initiates the asynchronous execution of the DescribeStreamSummary operation. /// /// /// Container for the necessary parameters to execute the DescribeStreamSummary operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStreamSummary /// operation. /// REST API Reference for DescribeStreamSummary Operation IAsyncResult BeginDescribeStreamSummary(DescribeStreamSummaryRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DescribeStreamSummary operation. /// /// /// The IAsyncResult returned by the call to BeginDescribeStreamSummary. /// /// Returns a DescribeStreamSummaryResult from Kinesis. /// REST API Reference for DescribeStreamSummary Operation DescribeStreamSummaryResponse EndDescribeStreamSummary(IAsyncResult asyncResult); #endregion #region DisableEnhancedMonitoring /// /// Disables enhanced monitoring. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// Container for the necessary parameters to execute the DisableEnhancedMonitoring service method. /// /// The response from the DisableEnhancedMonitoring service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for DisableEnhancedMonitoring Operation DisableEnhancedMonitoringResponse DisableEnhancedMonitoring(DisableEnhancedMonitoringRequest request); /// /// Initiates the asynchronous execution of the DisableEnhancedMonitoring operation. /// /// /// Container for the necessary parameters to execute the DisableEnhancedMonitoring operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableEnhancedMonitoring /// operation. /// REST API Reference for DisableEnhancedMonitoring Operation IAsyncResult BeginDisableEnhancedMonitoring(DisableEnhancedMonitoringRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the DisableEnhancedMonitoring operation. /// /// /// The IAsyncResult returned by the call to BeginDisableEnhancedMonitoring. /// /// Returns a DisableEnhancedMonitoringResult from Kinesis. /// REST API Reference for DisableEnhancedMonitoring Operation DisableEnhancedMonitoringResponse EndDisableEnhancedMonitoring(IAsyncResult asyncResult); #endregion #region EnableEnhancedMonitoring /// /// Enables enhanced Kinesis data stream monitoring for shard-level metrics. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// Container for the necessary parameters to execute the EnableEnhancedMonitoring service method. /// /// The response from the EnableEnhancedMonitoring service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for EnableEnhancedMonitoring Operation EnableEnhancedMonitoringResponse EnableEnhancedMonitoring(EnableEnhancedMonitoringRequest request); /// /// Initiates the asynchronous execution of the EnableEnhancedMonitoring operation. /// /// /// Container for the necessary parameters to execute the EnableEnhancedMonitoring operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableEnhancedMonitoring /// operation. /// REST API Reference for EnableEnhancedMonitoring Operation IAsyncResult BeginEnableEnhancedMonitoring(EnableEnhancedMonitoringRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the EnableEnhancedMonitoring operation. /// /// /// The IAsyncResult returned by the call to BeginEnableEnhancedMonitoring. /// /// Returns a EnableEnhancedMonitoringResult from Kinesis. /// REST API Reference for EnableEnhancedMonitoring Operation EnableEnhancedMonitoringResponse EndEnableEnhancedMonitoring(IAsyncResult asyncResult); #endregion #region GetRecords /// /// Gets data records from a Kinesis data stream's shard. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter in addition to the ShardIterator parameter. /// /// /// /// Specify a shard iterator using the ShardIterator parameter. The shard /// iterator specifies the position in the shard from which you want to start reading /// data records sequentially. If there are no records available in the portion of the /// shard that the iterator points to, GetRecords returns an empty list. It might /// take multiple calls to get to a portion of the shard that contains records. /// /// /// /// You can scale by provisioning multiple shards per stream while considering service /// limits (for more information, see Amazon /// Kinesis Data Streams Limits in the Amazon Kinesis Data Streams Developer Guide). /// Your application should have one thread per shard, each reading continuously from /// its stream. To read from a stream continually, call GetRecords in a loop. Use /// GetShardIterator to get the shard iterator to specify in the first GetRecords /// call. GetRecords returns a new shard iterator in NextShardIterator. /// Specify the shard iterator returned in NextShardIterator in subsequent /// calls to GetRecords. If the shard has been closed, the shard iterator can't /// return more data and GetRecords returns null in NextShardIterator. /// You can terminate the loop when the shard is closed, or when the shard iterator reaches /// the record with the sequence number or other attribute that marks it as the last record /// to process. /// /// /// /// Each data record can be up to 1 MiB in size, and each shard can read up to 2 MiB per /// second. You can ensure that your calls don't exceed the maximum supported size or /// throughput by using the Limit parameter to specify the maximum number /// of records that GetRecords can return. Consider your average record size when /// determining this limit. The maximum number of records that can be returned per call /// is 10,000. /// /// /// /// The size of the data returned by GetRecords varies depending on the utilization /// of the shard. It is recommended that consumer applications retrieve records via the /// GetRecords command using the 5 TPS limit to remain caught up. Retrieving /// records less frequently can lead to consumer applications falling behind. The maximum /// size of data that GetRecords can return is 10 MiB. If a call returns this amount /// of data, subsequent calls made within the next 5 seconds throw ProvisionedThroughputExceededException. /// If there is insufficient provisioned throughput on the stream, subsequent calls made /// within the next 1 second throw ProvisionedThroughputExceededException. /// GetRecords doesn't return any data when it throws an exception. For this reason, /// we recommend that you wait 1 second between calls to GetRecords. However, it's /// possible that the application will get exceptions for longer than 1 second. /// /// /// /// To detect whether the application is falling behind in processing, you can use the /// MillisBehindLatest response attribute. You can also monitor the stream /// using CloudWatch metrics and other mechanisms (see Monitoring /// in the Amazon Kinesis Data Streams Developer Guide). /// /// /// /// Each Amazon Kinesis record includes a value, ApproximateArrivalTimestamp, /// that is set when a stream successfully receives and stores a record. This is commonly /// referred to as a server-side time stamp, whereas a client-side time stamp is set when /// a data producer creates or sends the record to a stream (a data producer is any data /// source putting data records into a stream, for example with PutRecords). The /// time stamp has millisecond precision. There are no guarantees about the time stamp /// accuracy, or that the time stamp is always increasing. For example, records in a shard /// or across a stream might have time stamps that are out of order. /// /// /// /// This operation has a limit of five transactions per second per shard. /// /// /// Container for the necessary parameters to execute the GetRecords service method. /// /// The response from the GetRecords service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// The provided iterator exceeds the maximum age allowed. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The ciphertext references a key that doesn't exist or that you don't have access to. /// /// /// The request was rejected because the specified customer master key (CMK) isn't enabled. /// /// /// The request was rejected because the state of the specified resource isn't valid for /// this request. For more information, see How /// Key State Affects Use of a Customer Master Key in the Amazon Web Services Key /// Management Service Developer Guide. /// /// /// The request was rejected because the specified entity or resource can't be found. /// /// /// The Amazon Web Services access key ID needs a subscription for the service. /// /// /// The request was denied due to request throttling. For more information about throttling, /// see Limits /// in the Amazon Web Services Key Management Service Developer Guide. /// /// /// The request rate for the stream is too high, or the requested data is too large for /// the available throughput. Reduce the frequency or size of your requests. For more /// information, see Streams /// Limits in the Amazon Kinesis Data Streams Developer Guide, and Error /// Retries and Exponential Backoff in Amazon Web Services in the Amazon Web Services /// General Reference. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for GetRecords Operation GetRecordsResponse GetRecords(GetRecordsRequest request); /// /// Initiates the asynchronous execution of the GetRecords operation. /// /// /// Container for the necessary parameters to execute the GetRecords operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetRecords /// operation. /// REST API Reference for GetRecords Operation IAsyncResult BeginGetRecords(GetRecordsRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the GetRecords operation. /// /// /// The IAsyncResult returned by the call to BeginGetRecords. /// /// Returns a GetRecordsResult from Kinesis. /// REST API Reference for GetRecords Operation GetRecordsResponse EndGetRecords(IAsyncResult asyncResult); #endregion #region GetShardIterator /// /// Gets an Amazon Kinesis shard iterator. A shard iterator expires 5 minutes after it /// is returned to the requester. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// A shard iterator specifies the shard position from which to start reading data records /// sequentially. The position is specified using the sequence number of a data record /// in a shard. A sequence number is the identifier associated with every record ingested /// in the stream, and is assigned when a record is put into the stream. Each stream has /// one or more shards. /// /// /// /// You must specify the shard iterator type. For example, you can set the ShardIteratorType /// parameter to read exactly from the position denoted by a specific sequence number /// by using the AT_SEQUENCE_NUMBER shard iterator type. Alternatively, the /// parameter can read right after the sequence number by using the AFTER_SEQUENCE_NUMBER /// shard iterator type, using sequence numbers returned by earlier calls to PutRecord, /// PutRecords, GetRecords, or DescribeStream. In the request, you /// can specify the shard iterator type AT_TIMESTAMP to read records from /// an arbitrary point in time, TRIM_HORIZON to cause ShardIterator /// to point to the last untrimmed record in the shard in the system (the oldest data /// record in the shard), or LATEST so that you always read the most recent /// data in the shard. /// /// /// /// When you read repeatedly from a stream, use a GetShardIterator request to get /// the first shard iterator for use in your first GetRecords request and for subsequent /// reads use the shard iterator returned by the GetRecords request in NextShardIterator. /// A new shard iterator is returned by every GetRecords request in NextShardIterator, /// which you use in the ShardIterator parameter of the next GetRecords /// request. /// /// /// /// If a GetShardIterator request is made too often, you receive a ProvisionedThroughputExceededException. /// For more information about throughput limits, see GetRecords, and Streams /// Limits in the Amazon Kinesis Data Streams Developer Guide. /// /// /// /// If the shard is closed, GetShardIterator returns a valid iterator for the last /// sequence number of the shard. A shard can be closed as a result of using SplitShard /// or MergeShards. /// /// /// /// GetShardIterator has a limit of five transactions per second per account per /// open shard. /// /// /// Container for the necessary parameters to execute the GetShardIterator service method. /// /// The response from the GetShardIterator service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The request rate for the stream is too high, or the requested data is too large for /// the available throughput. Reduce the frequency or size of your requests. For more /// information, see Streams /// Limits in the Amazon Kinesis Data Streams Developer Guide, and Error /// Retries and Exponential Backoff in Amazon Web Services in the Amazon Web Services /// General Reference. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for GetShardIterator Operation GetShardIteratorResponse GetShardIterator(GetShardIteratorRequest request); /// /// Initiates the asynchronous execution of the GetShardIterator operation. /// /// /// Container for the necessary parameters to execute the GetShardIterator operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetShardIterator /// operation. /// REST API Reference for GetShardIterator Operation IAsyncResult BeginGetShardIterator(GetShardIteratorRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the GetShardIterator operation. /// /// /// The IAsyncResult returned by the call to BeginGetShardIterator. /// /// Returns a GetShardIteratorResult from Kinesis. /// REST API Reference for GetShardIterator Operation GetShardIteratorResponse EndGetShardIterator(IAsyncResult asyncResult); #endregion #region IncreaseStreamRetentionPeriod /// /// Increases the Kinesis data stream's retention period, which is the length of time /// data records are accessible after they are added to the stream. The maximum value /// of a stream's retention period is 8760 hours (365 days). /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// If you choose a longer stream retention period, this operation increases the time /// period during which records that have not yet expired are accessible. However, it /// does not make previous, expired data (older than the stream's previous retention period) /// accessible after the operation has been called. For example, if a stream's retention /// period is set to 24 hours and is increased to 168 hours, any data that is older than /// 24 hours remains inaccessible to consumer applications. /// /// /// The name of the stream to modify. /// The new retention period of the stream, in hours. Must be more than the current retention period. /// /// The response from the IncreaseStreamRetentionPeriod service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for IncreaseStreamRetentionPeriod Operation IncreaseStreamRetentionPeriodResponse IncreaseStreamRetentionPeriod(string streamName, int retentionPeriodHours); /// /// Increases the Kinesis data stream's retention period, which is the length of time /// data records are accessible after they are added to the stream. The maximum value /// of a stream's retention period is 8760 hours (365 days). /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// If you choose a longer stream retention period, this operation increases the time /// period during which records that have not yet expired are accessible. However, it /// does not make previous, expired data (older than the stream's previous retention period) /// accessible after the operation has been called. For example, if a stream's retention /// period is set to 24 hours and is increased to 168 hours, any data that is older than /// 24 hours remains inaccessible to consumer applications. /// /// /// Container for the necessary parameters to execute the IncreaseStreamRetentionPeriod service method. /// /// The response from the IncreaseStreamRetentionPeriod service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for IncreaseStreamRetentionPeriod Operation IncreaseStreamRetentionPeriodResponse IncreaseStreamRetentionPeriod(IncreaseStreamRetentionPeriodRequest request); /// /// Initiates the asynchronous execution of the IncreaseStreamRetentionPeriod operation. /// /// /// Container for the necessary parameters to execute the IncreaseStreamRetentionPeriod operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndIncreaseStreamRetentionPeriod /// operation. /// REST API Reference for IncreaseStreamRetentionPeriod Operation IAsyncResult BeginIncreaseStreamRetentionPeriod(IncreaseStreamRetentionPeriodRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the IncreaseStreamRetentionPeriod operation. /// /// /// The IAsyncResult returned by the call to BeginIncreaseStreamRetentionPeriod. /// /// Returns a IncreaseStreamRetentionPeriodResult from Kinesis. /// REST API Reference for IncreaseStreamRetentionPeriod Operation IncreaseStreamRetentionPeriodResponse EndIncreaseStreamRetentionPeriod(IAsyncResult asyncResult); #endregion #region ListShards /// /// Lists the shards in a stream and provides information about each shard. This operation /// has a limit of 1000 transactions per second per data stream. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// This action does not list expired shards. For information about expired shards, see /// Data /// Routing, Data Persistence, and Shard State after a Reshard. /// /// /// /// This API is a new operation that is used by the Amazon Kinesis Client Library (KCL). /// If you have a fine-grained IAM policy that only allows specific operations, you must /// update your policy to allow calls to this API. For more information, see Controlling /// Access to Amazon Kinesis Data Streams Resources Using IAM. /// /// /// /// Container for the necessary parameters to execute the ListShards service method. /// /// The response from the ListShards service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// The pagination token passed to the operation is expired. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for ListShards Operation ListShardsResponse ListShards(ListShardsRequest request); /// /// Initiates the asynchronous execution of the ListShards operation. /// /// /// Container for the necessary parameters to execute the ListShards operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListShards /// operation. /// REST API Reference for ListShards Operation IAsyncResult BeginListShards(ListShardsRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListShards operation. /// /// /// The IAsyncResult returned by the call to BeginListShards. /// /// Returns a ListShardsResult from Kinesis. /// REST API Reference for ListShards Operation ListShardsResponse EndListShards(IAsyncResult asyncResult); #endregion #region ListStreamConsumers /// /// Lists the consumers registered to receive data from a stream using enhanced fan-out, /// and provides information about each consumer. /// /// /// /// This operation has a limit of 5 transactions per second per stream. /// /// /// Container for the necessary parameters to execute the ListStreamConsumers service method. /// /// The response from the ListStreamConsumers service method, as returned by Kinesis. /// /// The pagination token passed to the operation is expired. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for ListStreamConsumers Operation ListStreamConsumersResponse ListStreamConsumers(ListStreamConsumersRequest request); /// /// Initiates the asynchronous execution of the ListStreamConsumers operation. /// /// /// Container for the necessary parameters to execute the ListStreamConsumers operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListStreamConsumers /// operation. /// REST API Reference for ListStreamConsumers Operation IAsyncResult BeginListStreamConsumers(ListStreamConsumersRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListStreamConsumers operation. /// /// /// The IAsyncResult returned by the call to BeginListStreamConsumers. /// /// Returns a ListStreamConsumersResult from Kinesis. /// REST API Reference for ListStreamConsumers Operation ListStreamConsumersResponse EndListStreamConsumers(IAsyncResult asyncResult); #endregion #region ListStreams /// /// Lists your Kinesis data streams. /// /// /// /// The number of streams may be too large to return from a single call to ListStreams. /// You can limit the number of returned streams using the Limit parameter. /// If you do not specify a value for the Limit parameter, Kinesis Data Streams /// uses the default limit, which is currently 100. /// /// /// /// You can detect if there are more streams available to list by using the HasMoreStreams /// flag from the returned output. If there are more streams available, you can request /// more streams by using the name of the last stream returned by the ListStreams /// request in the ExclusiveStartStreamName parameter in a subsequent request /// to ListStreams. The group of stream names returned by the subsequent /// request is then added to the list. You can continue this process until all the stream /// names have been collected in the list. /// /// /// /// ListStreams has a limit of five transactions per second per account. /// /// /// /// The response from the ListStreams service method, as returned by Kinesis. /// /// The pagination token passed to the operation is expired. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// REST API Reference for ListStreams Operation ListStreamsResponse ListStreams(); /// /// Lists your Kinesis data streams. /// /// /// /// The number of streams may be too large to return from a single call to ListStreams. /// You can limit the number of returned streams using the Limit parameter. /// If you do not specify a value for the Limit parameter, Kinesis Data Streams /// uses the default limit, which is currently 100. /// /// /// /// You can detect if there are more streams available to list by using the HasMoreStreams /// flag from the returned output. If there are more streams available, you can request /// more streams by using the name of the last stream returned by the ListStreams /// request in the ExclusiveStartStreamName parameter in a subsequent request /// to ListStreams. The group of stream names returned by the subsequent /// request is then added to the list. You can continue this process until all the stream /// names have been collected in the list. /// /// /// /// ListStreams has a limit of five transactions per second per account. /// /// /// Container for the necessary parameters to execute the ListStreams service method. /// /// The response from the ListStreams service method, as returned by Kinesis. /// /// The pagination token passed to the operation is expired. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// REST API Reference for ListStreams Operation ListStreamsResponse ListStreams(ListStreamsRequest request); /// /// Initiates the asynchronous execution of the ListStreams operation. /// /// /// Container for the necessary parameters to execute the ListStreams operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListStreams /// operation. /// REST API Reference for ListStreams Operation IAsyncResult BeginListStreams(ListStreamsRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListStreams operation. /// /// /// The IAsyncResult returned by the call to BeginListStreams. /// /// Returns a ListStreamsResult from Kinesis. /// REST API Reference for ListStreams Operation ListStreamsResponse EndListStreams(IAsyncResult asyncResult); #endregion #region ListTagsForStream /// /// Lists the tags for the specified Kinesis data stream. This operation has a limit of /// five transactions per second per account. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// Container for the necessary parameters to execute the ListTagsForStream service method. /// /// The response from the ListTagsForStream service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for ListTagsForStream Operation ListTagsForStreamResponse ListTagsForStream(ListTagsForStreamRequest request); /// /// Initiates the asynchronous execution of the ListTagsForStream operation. /// /// /// Container for the necessary parameters to execute the ListTagsForStream operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForStream /// operation. /// REST API Reference for ListTagsForStream Operation IAsyncResult BeginListTagsForStream(ListTagsForStreamRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the ListTagsForStream operation. /// /// /// The IAsyncResult returned by the call to BeginListTagsForStream. /// /// Returns a ListTagsForStreamResult from Kinesis. /// REST API Reference for ListTagsForStream Operation ListTagsForStreamResponse EndListTagsForStream(IAsyncResult asyncResult); #endregion #region MergeShards /// /// Merges two adjacent shards in a Kinesis data stream and combines them into a single /// shard to reduce the stream's capacity to ingest and transport data. This API is only /// supported for the data streams with the provisioned capacity mode. Two shards are /// considered adjacent if the union of the hash key ranges for the two shards form a /// contiguous set with no gaps. For example, if you have two shards, one with a hash /// key range of 276...381 and the other with a hash key range of 382...454, then you /// could merge these two shards into a single shard that would have a hash key range /// of 276...454. After the merge, the single child shard receives data for all hash key /// values covered by the two parent shards. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// MergeShards is called when there is a need to reduce the overall capacity /// of a stream because of excess capacity that is not being used. You must specify the /// shard to be merged and the adjacent shard for a stream. For more information about /// merging shards, see Merge /// Two Shards in the Amazon Kinesis Data Streams Developer Guide. /// /// /// /// If the stream is in the ACTIVE state, you can call MergeShards. /// If a stream is in the CREATING, UPDATING, or DELETING /// state, MergeShards returns a ResourceInUseException. If /// the specified stream does not exist, MergeShards returns a ResourceNotFoundException. /// /// /// /// /// You can use DescribeStreamSummary to check the state of the stream, which is /// returned in StreamStatus. /// /// /// /// MergeShards is an asynchronous operation. Upon receiving a MergeShards /// request, Amazon Kinesis Data Streams immediately returns a response and sets the StreamStatus /// to UPDATING. After the operation is completed, Kinesis Data Streams sets /// the StreamStatus to ACTIVE. Read and write operations continue /// to work while the stream is in the UPDATING state. /// /// /// /// You use DescribeStreamSummary and the ListShards APIs to determine the /// shard IDs that are specified in the MergeShards request. /// /// /// /// If you try to operate on too many streams in parallel using CreateStream, DeleteStream, /// MergeShards, or SplitShard, you receive a LimitExceededException. /// /// /// /// /// MergeShards has a limit of five transactions per second per account. /// /// /// Container for the necessary parameters to execute the MergeShards service method. /// /// The response from the MergeShards service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// /// Specifies that you tried to invoke this API for a data stream with the on-demand capacity /// mode. This API is only supported for data streams with the provisioned capacity mode. /// /// REST API Reference for MergeShards Operation MergeShardsResponse MergeShards(MergeShardsRequest request); /// /// Initiates the asynchronous execution of the MergeShards operation. /// /// /// Container for the necessary parameters to execute the MergeShards operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndMergeShards /// operation. /// REST API Reference for MergeShards Operation IAsyncResult BeginMergeShards(MergeShardsRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the MergeShards operation. /// /// /// The IAsyncResult returned by the call to BeginMergeShards. /// /// Returns a MergeShardsResult from Kinesis. /// REST API Reference for MergeShards Operation MergeShardsResponse EndMergeShards(IAsyncResult asyncResult); #endregion #region PutRecord /// /// Writes a single data record into an Amazon Kinesis data stream. Call PutRecord /// to send data into the stream for real-time ingestion and subsequent processing, one /// record at a time. Each shard can support writes up to 1,000 records per second, up /// to a maximum data write total of 1 MiB per second. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// You must specify the name of the stream that captures, stores, and transports the /// data; a partition key; and the data blob itself. /// /// /// /// The data blob can be any type of data; for example, a segment from a log file, geographic/location /// data, website clickstream data, and so on. /// /// /// /// The partition key is used by Kinesis Data Streams to distribute data across shards. /// Kinesis Data Streams segregates the data records that belong to a stream into multiple /// shards, using the partition key associated with each data record to determine the /// shard to which a given data record belongs. /// /// /// /// Partition keys are Unicode strings, with a maximum length limit of 256 characters /// for each key. An MD5 hash function is used to map partition keys to 128-bit integer /// values and to map associated data records to shards using the hash key ranges of the /// shards. You can override hashing the partition key to determine the shard by explicitly /// specifying a hash value using the ExplicitHashKey parameter. For more /// information, see Adding /// Data to a Stream in the Amazon Kinesis Data Streams Developer Guide. /// /// /// /// PutRecord returns the shard ID of where the data record was placed and /// the sequence number that was assigned to the data record. /// /// /// /// Sequence numbers increase over time and are specific to a shard within a stream, not /// across all shards within a stream. To guarantee strictly increasing ordering, write /// serially to a shard and use the SequenceNumberForOrdering parameter. /// For more information, see Adding /// Data to a Stream in the Amazon Kinesis Data Streams Developer Guide. /// /// /// /// After you write a record to a stream, you cannot modify that record or its order within /// the stream. /// /// /// /// If a PutRecord request cannot be processed because of insufficient provisioned /// throughput on the shard involved in the request, PutRecord throws ProvisionedThroughputExceededException. /// /// /// /// /// By default, data records are accessible for 24 hours from the time that they are added /// to a stream. You can use IncreaseStreamRetentionPeriod or DecreaseStreamRetentionPeriod /// to modify this retention period. /// /// /// Container for the necessary parameters to execute the PutRecord service method. /// /// The response from the PutRecord service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The ciphertext references a key that doesn't exist or that you don't have access to. /// /// /// The request was rejected because the specified customer master key (CMK) isn't enabled. /// /// /// The request was rejected because the state of the specified resource isn't valid for /// this request. For more information, see How /// Key State Affects Use of a Customer Master Key in the Amazon Web Services Key /// Management Service Developer Guide. /// /// /// The request was rejected because the specified entity or resource can't be found. /// /// /// The Amazon Web Services access key ID needs a subscription for the service. /// /// /// The request was denied due to request throttling. For more information about throttling, /// see Limits /// in the Amazon Web Services Key Management Service Developer Guide. /// /// /// The request rate for the stream is too high, or the requested data is too large for /// the available throughput. Reduce the frequency or size of your requests. For more /// information, see Streams /// Limits in the Amazon Kinesis Data Streams Developer Guide, and Error /// Retries and Exponential Backoff in Amazon Web Services in the Amazon Web Services /// General Reference. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for PutRecord Operation PutRecordResponse PutRecord(PutRecordRequest request); /// /// Initiates the asynchronous execution of the PutRecord operation. /// /// /// Container for the necessary parameters to execute the PutRecord operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutRecord /// operation. /// REST API Reference for PutRecord Operation IAsyncResult BeginPutRecord(PutRecordRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the PutRecord operation. /// /// /// The IAsyncResult returned by the call to BeginPutRecord. /// /// Returns a PutRecordResult from Kinesis. /// REST API Reference for PutRecord Operation PutRecordResponse EndPutRecord(IAsyncResult asyncResult); #endregion #region PutRecords /// /// Writes multiple data records into a Kinesis data stream in a single call (also referred /// to as a PutRecords request). Use this operation to send data into the /// stream for data ingestion and processing. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// Each PutRecords request can support up to 500 records. Each record in /// the request can be as large as 1 MiB, up to a limit of 5 MiB for the entire request, /// including partition keys. Each shard can support writes up to 1,000 records per second, /// up to a maximum data write total of 1 MiB per second. /// /// /// /// You must specify the name of the stream that captures, stores, and transports the /// data; and an array of request Records, with each record in the array /// requiring a partition key and data blob. The record size limit applies to the total /// size of the partition key and data blob. /// /// /// /// The data blob can be any type of data; for example, a segment from a log file, geographic/location /// data, website clickstream data, and so on. /// /// /// /// The partition key is used by Kinesis Data Streams as input to a hash function that /// maps the partition key and associated data to a specific shard. An MD5 hash function /// is used to map partition keys to 128-bit integer values and to map associated data /// records to shards. As a result of this hashing mechanism, all data records with the /// same partition key map to the same shard within the stream. For more information, /// see Adding /// Data to a Stream in the Amazon Kinesis Data Streams Developer Guide. /// /// /// /// Each record in the Records array may include an optional parameter, ExplicitHashKey, /// which overrides the partition key to shard mapping. This parameter allows a data producer /// to determine explicitly the shard where the record is stored. For more information, /// see Adding /// Multiple Records with PutRecords in the Amazon Kinesis Data Streams Developer /// Guide. /// /// /// /// The PutRecords response includes an array of response Records. /// Each record in the response array directly correlates with a record in the request /// array using natural ordering, from the top to the bottom of the request and response. /// The response Records array always includes the same number of records /// as the request array. /// /// /// /// The response Records array includes both successfully and unsuccessfully /// processed records. Kinesis Data Streams attempts to process all records in each PutRecords /// request. A single record failure does not stop the processing of subsequent records. /// As a result, PutRecords doesn't guarantee the ordering of records. If you need to /// read records in the same order they are written to the stream, use PutRecord /// instead of PutRecords, and write to the same shard. /// /// /// /// A successfully processed record includes ShardId and SequenceNumber /// values. The ShardId parameter identifies the shard in the stream where /// the record is stored. The SequenceNumber parameter is an identifier assigned /// to the put record, unique to all records in the stream. /// /// /// /// An unsuccessfully processed record includes ErrorCode and ErrorMessage /// values. ErrorCode reflects the type of error and can be one of the following /// values: ProvisionedThroughputExceededException or InternalFailure. /// ErrorMessage provides more detailed information about the ProvisionedThroughputExceededException /// exception including the account ID, stream name, and shard ID of the record that was /// throttled. For more information about partially successful responses, see Adding /// Multiple Records with PutRecords in the Amazon Kinesis Data Streams Developer /// Guide. /// /// /// /// After you write a record to a stream, you cannot modify that record or its order within /// the stream. /// /// /// /// By default, data records are accessible for 24 hours from the time that they are added /// to a stream. You can use IncreaseStreamRetentionPeriod or DecreaseStreamRetentionPeriod /// to modify this retention period. /// /// /// Container for the necessary parameters to execute the PutRecords service method. /// /// The response from the PutRecords service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The ciphertext references a key that doesn't exist or that you don't have access to. /// /// /// The request was rejected because the specified customer master key (CMK) isn't enabled. /// /// /// The request was rejected because the state of the specified resource isn't valid for /// this request. For more information, see How /// Key State Affects Use of a Customer Master Key in the Amazon Web Services Key /// Management Service Developer Guide. /// /// /// The request was rejected because the specified entity or resource can't be found. /// /// /// The Amazon Web Services access key ID needs a subscription for the service. /// /// /// The request was denied due to request throttling. For more information about throttling, /// see Limits /// in the Amazon Web Services Key Management Service Developer Guide. /// /// /// The request rate for the stream is too high, or the requested data is too large for /// the available throughput. Reduce the frequency or size of your requests. For more /// information, see Streams /// Limits in the Amazon Kinesis Data Streams Developer Guide, and Error /// Retries and Exponential Backoff in Amazon Web Services in the Amazon Web Services /// General Reference. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for PutRecords Operation PutRecordsResponse PutRecords(PutRecordsRequest request); /// /// Initiates the asynchronous execution of the PutRecords operation. /// /// /// Container for the necessary parameters to execute the PutRecords operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutRecords /// operation. /// REST API Reference for PutRecords Operation IAsyncResult BeginPutRecords(PutRecordsRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the PutRecords operation. /// /// /// The IAsyncResult returned by the call to BeginPutRecords. /// /// Returns a PutRecordsResult from Kinesis. /// REST API Reference for PutRecords Operation PutRecordsResponse EndPutRecords(IAsyncResult asyncResult); #endregion #region RegisterStreamConsumer /// /// Registers a consumer with a Kinesis data stream. When you use this operation, the /// consumer you register can then call SubscribeToShard to receive data from the /// stream using enhanced fan-out, at a rate of up to 2 MiB per second for every shard /// you subscribe to. This rate is unaffected by the total number of consumers that read /// from the same stream. /// /// /// /// You can register up to 20 consumers per stream. A given consumer can only be registered /// with one stream at a time. /// /// /// /// For an example of how to use this operations, see Enhanced /// Fan-Out Using the Kinesis Data Streams API. /// /// /// /// The use of this operation has a limit of five transactions per second per account. /// Also, only 5 consumers can be created simultaneously. In other words, you cannot have /// more than 5 consumers in a CREATING status at the same time. Registering /// a 6th consumer while there are 5 in a CREATING status results in a LimitExceededException. /// /// /// Container for the necessary parameters to execute the RegisterStreamConsumer service method. /// /// The response from the RegisterStreamConsumer service method, as returned by Kinesis. /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for RegisterStreamConsumer Operation RegisterStreamConsumerResponse RegisterStreamConsumer(RegisterStreamConsumerRequest request); /// /// Initiates the asynchronous execution of the RegisterStreamConsumer operation. /// /// /// Container for the necessary parameters to execute the RegisterStreamConsumer operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterStreamConsumer /// operation. /// REST API Reference for RegisterStreamConsumer Operation IAsyncResult BeginRegisterStreamConsumer(RegisterStreamConsumerRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the RegisterStreamConsumer operation. /// /// /// The IAsyncResult returned by the call to BeginRegisterStreamConsumer. /// /// Returns a RegisterStreamConsumerResult from Kinesis. /// REST API Reference for RegisterStreamConsumer Operation RegisterStreamConsumerResponse EndRegisterStreamConsumer(IAsyncResult asyncResult); #endregion #region RemoveTagsFromStream /// /// Removes tags from the specified Kinesis data stream. Removed tags are deleted and /// cannot be recovered after this operation successfully completes. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// If you specify a tag that does not exist, it is ignored. /// /// /// /// RemoveTagsFromStream has a limit of five transactions per second per account. /// /// /// Container for the necessary parameters to execute the RemoveTagsFromStream service method. /// /// The response from the RemoveTagsFromStream service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for RemoveTagsFromStream Operation RemoveTagsFromStreamResponse RemoveTagsFromStream(RemoveTagsFromStreamRequest request); /// /// Initiates the asynchronous execution of the RemoveTagsFromStream operation. /// /// /// Container for the necessary parameters to execute the RemoveTagsFromStream operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRemoveTagsFromStream /// operation. /// REST API Reference for RemoveTagsFromStream Operation IAsyncResult BeginRemoveTagsFromStream(RemoveTagsFromStreamRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the RemoveTagsFromStream operation. /// /// /// The IAsyncResult returned by the call to BeginRemoveTagsFromStream. /// /// Returns a RemoveTagsFromStreamResult from Kinesis. /// REST API Reference for RemoveTagsFromStream Operation RemoveTagsFromStreamResponse EndRemoveTagsFromStream(IAsyncResult asyncResult); #endregion #region SplitShard /// /// Splits a shard into two new shards in the Kinesis data stream, to increase the stream's /// capacity to ingest and transport data. SplitShard is called when there /// is a need to increase the overall capacity of a stream because of an expected increase /// in the volume of data records being ingested. This API is only supported for the data /// streams with the provisioned capacity mode. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// You can also use SplitShard when a shard appears to be approaching its /// maximum utilization; for example, the producers sending data into the specific shard /// are suddenly sending more than previously anticipated. You can also call SplitShard /// to increase stream capacity, so that more Kinesis Data Streams applications can simultaneously /// read data from the stream for real-time processing. /// /// /// /// You must specify the shard to be split and the new hash key, which is the position /// in the shard where the shard gets split in two. In many cases, the new hash key might /// be the average of the beginning and ending hash key, but it can be any hash key value /// in the range being mapped into the shard. For more information, see Split /// a Shard in the Amazon Kinesis Data Streams Developer Guide. /// /// /// /// You can use DescribeStreamSummary and the ListShards APIs to determine /// the shard ID and hash key values for the ShardToSplit and NewStartingHashKey /// parameters that are specified in the SplitShard request. /// /// /// /// SplitShard is an asynchronous operation. Upon receiving a SplitShard /// request, Kinesis Data Streams immediately returns a response and sets the stream status /// to UPDATING. After the operation is completed, Kinesis Data Streams sets /// the stream status to ACTIVE. Read and write operations continue to work /// while the stream is in the UPDATING state. /// /// /// /// You can use DescribeStreamSummary to check the status of the stream, which /// is returned in StreamStatus. If the stream is in the ACTIVE /// state, you can call SplitShard. /// /// /// /// If the specified stream does not exist, DescribeStreamSummary returns a ResourceNotFoundException. /// If you try to create more shards than are authorized for your account, you receive /// a LimitExceededException. /// /// /// /// For the default shard limit for an Amazon Web Services account, see Kinesis /// Data Streams Limits in the Amazon Kinesis Data Streams Developer Guide. /// To increase this limit, contact /// Amazon Web Services Support. /// /// /// /// If you try to operate on too many streams simultaneously using CreateStream, /// DeleteStream, MergeShards, and/or SplitShard, you receive a LimitExceededException. /// /// /// /// /// SplitShard has a limit of five transactions per second per account. /// /// /// Container for the necessary parameters to execute the SplitShard service method. /// /// The response from the SplitShard service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// /// Specifies that you tried to invoke this API for a data stream with the on-demand capacity /// mode. This API is only supported for data streams with the provisioned capacity mode. /// /// REST API Reference for SplitShard Operation SplitShardResponse SplitShard(SplitShardRequest request); /// /// Initiates the asynchronous execution of the SplitShard operation. /// /// /// Container for the necessary parameters to execute the SplitShard operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSplitShard /// operation. /// REST API Reference for SplitShard Operation IAsyncResult BeginSplitShard(SplitShardRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the SplitShard operation. /// /// /// The IAsyncResult returned by the call to BeginSplitShard. /// /// Returns a SplitShardResult from Kinesis. /// REST API Reference for SplitShard Operation SplitShardResponse EndSplitShard(IAsyncResult asyncResult); #endregion #region StartStreamEncryption /// /// Enables or updates server-side encryption using an Amazon Web Services KMS key for /// a specified stream. /// /// /// /// Starting encryption is an asynchronous operation. Upon receiving the request, Kinesis /// Data Streams returns immediately and sets the status of the stream to UPDATING. /// After the update is complete, Kinesis Data Streams sets the status of the stream back /// to ACTIVE. Updating or applying encryption normally takes a few seconds /// to complete, but it can take minutes. You can continue to read and write data to your /// stream while its status is UPDATING. Once the status of the stream is /// ACTIVE, encryption begins for records written to the stream. /// /// /// /// API Limits: You can successfully apply a new Amazon Web Services KMS key for server-side /// encryption 25 times in a rolling 24-hour period. /// /// /// /// Note: It can take up to 5 seconds after the stream is in an ACTIVE status /// before all records written to the stream are encrypted. After you enable encryption, /// you can verify that encryption is applied by inspecting the API response from PutRecord /// or PutRecords. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// Container for the necessary parameters to execute the StartStreamEncryption service method. /// /// The response from the StartStreamEncryption service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The ciphertext references a key that doesn't exist or that you don't have access to. /// /// /// The request was rejected because the specified customer master key (CMK) isn't enabled. /// /// /// The request was rejected because the state of the specified resource isn't valid for /// this request. For more information, see How /// Key State Affects Use of a Customer Master Key in the Amazon Web Services Key /// Management Service Developer Guide. /// /// /// The request was rejected because the specified entity or resource can't be found. /// /// /// The Amazon Web Services access key ID needs a subscription for the service. /// /// /// The request was denied due to request throttling. For more information about throttling, /// see Limits /// in the Amazon Web Services Key Management Service Developer Guide. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for StartStreamEncryption Operation StartStreamEncryptionResponse StartStreamEncryption(StartStreamEncryptionRequest request); /// /// Initiates the asynchronous execution of the StartStreamEncryption operation. /// /// /// Container for the necessary parameters to execute the StartStreamEncryption operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartStreamEncryption /// operation. /// REST API Reference for StartStreamEncryption Operation IAsyncResult BeginStartStreamEncryption(StartStreamEncryptionRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the StartStreamEncryption operation. /// /// /// The IAsyncResult returned by the call to BeginStartStreamEncryption. /// /// Returns a StartStreamEncryptionResult from Kinesis. /// REST API Reference for StartStreamEncryption Operation StartStreamEncryptionResponse EndStartStreamEncryption(IAsyncResult asyncResult); #endregion #region StopStreamEncryption /// /// Disables server-side encryption for a specified stream. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// Stopping encryption is an asynchronous operation. Upon receiving the request, Kinesis /// Data Streams returns immediately and sets the status of the stream to UPDATING. /// After the update is complete, Kinesis Data Streams sets the status of the stream back /// to ACTIVE. Stopping encryption normally takes a few seconds to complete, /// but it can take minutes. You can continue to read and write data to your stream while /// its status is UPDATING. Once the status of the stream is ACTIVE, /// records written to the stream are no longer encrypted by Kinesis Data Streams. /// /// /// /// API Limits: You can successfully disable server-side encryption 25 times in a rolling /// 24-hour period. /// /// /// /// Note: It can take up to 5 seconds after the stream is in an ACTIVE status /// before all records written to the stream are no longer subject to encryption. After /// you disabled encryption, you can verify that encryption is not applied by inspecting /// the API response from PutRecord or PutRecords. /// /// /// Container for the necessary parameters to execute the StopStreamEncryption service method. /// /// The response from the StopStreamEncryption service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for StopStreamEncryption Operation StopStreamEncryptionResponse StopStreamEncryption(StopStreamEncryptionRequest request); /// /// Initiates the asynchronous execution of the StopStreamEncryption operation. /// /// /// Container for the necessary parameters to execute the StopStreamEncryption operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopStreamEncryption /// operation. /// REST API Reference for StopStreamEncryption Operation IAsyncResult BeginStopStreamEncryption(StopStreamEncryptionRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the StopStreamEncryption operation. /// /// /// The IAsyncResult returned by the call to BeginStopStreamEncryption. /// /// Returns a StopStreamEncryptionResult from Kinesis. /// REST API Reference for StopStreamEncryption Operation StopStreamEncryptionResponse EndStopStreamEncryption(IAsyncResult asyncResult); #endregion #region UpdateShardCount /// /// Updates the shard count of the specified stream to the specified number of shards. /// This API is only supported for the data streams with the provisioned capacity mode. /// /// /// /// When invoking this API, it is recommended you use the StreamARN input /// parameter rather than the StreamName input parameter. /// /// /// /// Updating the shard count is an asynchronous operation. Upon receiving the request, /// Kinesis Data Streams returns immediately and sets the status of the stream to UPDATING. /// After the update is complete, Kinesis Data Streams sets the status of the stream back /// to ACTIVE. Depending on the size of the stream, the scaling action could /// take a few minutes to complete. You can continue to read and write data to your stream /// while its status is UPDATING. /// /// /// /// To update the shard count, Kinesis Data Streams performs splits or merges on individual /// shards. This can cause short-lived shards to be created, in addition to the final /// shards. These short-lived shards count towards your total shard limit for your account /// in the Region. /// /// /// /// When using this operation, we recommend that you specify a target shard count that /// is a multiple of 25% (25%, 50%, 75%, 100%). You can specify any target value within /// your shard limit. However, if you specify a target that isn't a multiple of 25%, the /// scaling action might take longer to complete. /// /// /// /// This operation has the following default limits. By default, you cannot do the following: /// /// /// /// For the default limits for an Amazon Web Services account, see Streams /// Limits in the Amazon Kinesis Data Streams Developer Guide. To request an /// increase in the call rate limit, the shard limit for this API, or your overall shard /// limit, use the limits /// form. /// /// /// Container for the necessary parameters to execute the UpdateShardCount service method. /// /// The response from the UpdateShardCount service method, as returned by Kinesis. /// /// Specifies that you do not have the permissions required to perform this operation. /// /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// /// Specifies that you tried to invoke this API for a data stream with the on-demand capacity /// mode. This API is only supported for data streams with the provisioned capacity mode. /// /// REST API Reference for UpdateShardCount Operation UpdateShardCountResponse UpdateShardCount(UpdateShardCountRequest request); /// /// Initiates the asynchronous execution of the UpdateShardCount operation. /// /// /// Container for the necessary parameters to execute the UpdateShardCount operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateShardCount /// operation. /// REST API Reference for UpdateShardCount Operation IAsyncResult BeginUpdateShardCount(UpdateShardCountRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the UpdateShardCount operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateShardCount. /// /// Returns a UpdateShardCountResult from Kinesis. /// REST API Reference for UpdateShardCount Operation UpdateShardCountResponse EndUpdateShardCount(IAsyncResult asyncResult); #endregion #region UpdateStreamMode /// /// Updates the capacity mode of the data stream. Currently, in Kinesis Data Streams, /// you can choose between an on-demand capacity mode and a provisioned /// capacity mode for your data stream. /// /// Container for the necessary parameters to execute the UpdateStreamMode service method. /// /// The response from the UpdateStreamMode service method, as returned by Kinesis. /// /// A specified parameter exceeds its restrictions, is not supported, or can't be used. /// For more information, see the returned message. /// /// /// The requested resource exceeds the maximum number allowed, or the number of concurrent /// stream requests exceeds the maximum number allowed. /// /// /// The resource is not available for this operation. For successful operation, the resource /// must be in the ACTIVE state. /// /// /// The requested resource could not be found. The stream might not be specified correctly. /// /// REST API Reference for UpdateStreamMode Operation UpdateStreamModeResponse UpdateStreamMode(UpdateStreamModeRequest request); /// /// Initiates the asynchronous execution of the UpdateStreamMode operation. /// /// /// Container for the necessary parameters to execute the UpdateStreamMode operation on AmazonKinesisClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateStreamMode /// operation. /// REST API Reference for UpdateStreamMode Operation IAsyncResult BeginUpdateStreamMode(UpdateStreamModeRequest request, AsyncCallback callback, object state); /// /// Finishes the asynchronous execution of the UpdateStreamMode operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateStreamMode. /// /// Returns a UpdateStreamModeResult from Kinesis. /// REST API Reference for UpdateStreamMode Operation UpdateStreamModeResponse EndUpdateStreamMode(IAsyncResult asyncResult); #endregion } }