diff --git a/Makefile b/Makefile index 4694a033..cce4e416 100644 --- a/Makefile +++ b/Makefile @@ -139,6 +139,7 @@ test/fakes: $(GO) run github.com/maxbrunsfeld/counterfeiter/v6 -o backends/rabbitmq/rabbitfakes/fake_rabbit.go github.com/batchcorp/rabbit.IRabbit $(GO) run github.com/maxbrunsfeld/counterfeiter/v6 -o backends/awssns/snsfakes/fake_sns.go github.com/aws/aws-sdk-go/service/sns/snsiface.SNSAPI $(GO) run github.com/maxbrunsfeld/counterfeiter/v6 -o backends/awssqs/sqsfakes/fake_sqs.go github.com/aws/aws-sdk-go/service/sqs/sqsiface.SQSAPI + $(GO) run github.com/maxbrunsfeld/counterfeiter/v6 -o backends/awskinesis/kinesisfakes/fake_kinesis.go github.com/aws/aws-sdk-go/service/kinesis/kinesisiface.KinesisAPI $(GO) run github.com/maxbrunsfeld/counterfeiter/v6 -o backends/nats-streaming/stanfakes/fake_stan.go github.com/nats-io/stan.go.Conn $(GO) run github.com/maxbrunsfeld/counterfeiter/v6 -o backends/nats-streaming/stanfakes/fake_subscription.go github.com/nats-io/stan.go.Subscription $(GO) generate ./... diff --git a/README.md b/README.md index 629ae90e..65345abe 100644 --- a/README.md +++ b/README.md @@ -180,6 +180,7 @@ We consider ourselves "internet plumbers" of sort - so the name seemed to fit :) * RabbitMQ Streams * Google Cloud Platform PubSub * MQTT +* Amazon Kinesis Streams **(NEW)** * Amazon SQS * Amazon SNS (Publishing) * ActiveMQ (STOMP protocol) diff --git a/backends/awskinesis/awskinesis.go b/backends/awskinesis/awskinesis.go new file mode 100644 index 00000000..91cccfab --- /dev/null +++ b/backends/awskinesis/awskinesis.go @@ -0,0 +1,98 @@ +package awskinesis + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/credentials" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/kinesis" + "github.com/aws/aws-sdk-go/service/kinesis/kinesisiface" + "github.com/pkg/errors" + "github.com/sirupsen/logrus" + + "github.com/batchcorp/plumber/types" + "github.com/batchcorp/plumber/validate" + + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" +) + +const BackendName = "kinesis" + +var ( + ErrEmptyPartitionKey = errors.New("partition key cannot be empty") + ErrEmptyStream = errors.New("stream cannot be empty") + ErrEmptyShard = errors.New("shard cannot be empty") + ErrEmptyShardWithSequence = errors.New("when reading from all shards, you cannot specify a sequence number") +) + +type Kinesis struct { + connOpts *opts.ConnectionOptions + client kinesisiface.KinesisAPI + readCount uint64 + log *logrus.Entry +} + +func New(connOpts *opts.ConnectionOptions) (*Kinesis, error) { + if err := validateBaseConnOpts(connOpts); err != nil { + return nil, errors.Wrap(err, "invalid connection options") + } + + connArgs := connOpts.GetAwsKinesis() + + sess, err := session.NewSession(&aws.Config{ + Region: aws.String(connArgs.AwsRegion), + Credentials: credentials.NewStaticCredentials(connArgs.AwsAccessKeyId, connArgs.AwsSecretAccessKey, ""), + }) + if err != nil { + return nil, errors.Wrap(err, "unable to initialize aws session") + } + + return &Kinesis{ + connOpts: connOpts, + client: kinesis.New(sess), + log: logrus.WithField("backend", BackendName), + }, nil +} + +func (k *Kinesis) Name() string { + return BackendName +} + +func (k *Kinesis) Close(_ context.Context) error { + // Not needed. AWS clients are REST calls + return nil +} + +func (k *Kinesis) Test(_ context.Context) error { + return types.NotImplementedErr +} + +func validateBaseConnOpts(connOpts *opts.ConnectionOptions) error { + if connOpts == nil { + return validate.ErrMissingConnOpts + } + + if connOpts.Conn == nil { + return validate.ErrMissingConnCfg + } + + args := connOpts.GetAwsKinesis() + if args == nil { + return validate.ErrMissingConnArgs + } + + if args.AwsSecretAccessKey == "" { + return validate.ErrMissingAWSSecretAccessKey + } + + if args.AwsRegion == "" { + return validate.ErrMissingAWSRegion + } + + if args.AwsAccessKeyId == "" { + return validate.ErrMissingAWSAccessKeyID + } + + return nil +} diff --git a/backends/awskinesis/awskinesis_suite_test.go b/backends/awskinesis/awskinesis_suite_test.go new file mode 100644 index 00000000..e3ca076f --- /dev/null +++ b/backends/awskinesis/awskinesis_suite_test.go @@ -0,0 +1,13 @@ +package awskinesis_test + +import ( + "testing" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +func TestAwskinesis(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "Awskinesis Suite") +} diff --git a/backends/awskinesis/awskinesis_test.go b/backends/awskinesis/awskinesis_test.go new file mode 100644 index 00000000..03546db0 --- /dev/null +++ b/backends/awskinesis/awskinesis_test.go @@ -0,0 +1,88 @@ +package awskinesis + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "github.com/batchcorp/plumber/types" + "github.com/batchcorp/plumber/validate" + + "github.com/batchcorp/plumber-schemas/build/go/protos/args" + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" +) + +var _ = Describe("AWS Kinesis Backend", func() { + var connOpts *opts.ConnectionOptions + + BeforeEach(func() { + connOpts = &opts.ConnectionOptions{ + Conn: &opts.ConnectionOptions_AwsKinesis{ + AwsKinesis: &args.AWSKinesisConn{ + AwsRegion: "us-east-1", + AwsSecretAccessKey: "test", + AwsAccessKeyId: "test", + }, + }, + } + }) + + Context("validateBaseConnOpts", func() { + It("validates conn presence", func() { + err := validateBaseConnOpts(nil) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrMissingConnOpts)) + }) + It("validates conn config", func() { + connOpts = &opts.ConnectionOptions{} + err := validateBaseConnOpts(connOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrMissingConnCfg)) + }) + It("validates Kinesis options presence", func() { + connOpts = &opts.ConnectionOptions{ + Conn: &opts.ConnectionOptions_AwsKinesis{ + AwsKinesis: nil, + }, + } + err := validateBaseConnOpts(connOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrMissingConnArgs)) + }) + It("validates AWS secret access key", func() { + connOpts.GetAwsKinesis().AwsSecretAccessKey = "" + err := validateBaseConnOpts(connOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrMissingAWSSecretAccessKey)) + }) + It("validates AWS region", func() { + connOpts.GetAwsKinesis().AwsRegion = "" + err := validateBaseConnOpts(connOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrMissingAWSRegion)) + }) + It("validates AWS key ID", func() { + connOpts.GetAwsKinesis().AwsAccessKeyId = "" + err := validateBaseConnOpts(connOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrMissingAWSAccessKeyID)) + }) + }) + + Context("Name", func() { + It("returns backend name", func() { + Expect((&Kinesis{}).Name()).To(Equal(BackendName)) + }) + }) + + Context("Test", func() { + It("returns not implemented error", func() { + Expect((&Kinesis{}).Test(nil)).To(Equal(types.NotImplementedErr)) + }) + }) + + Context("Close", func() { + It("returns nil", func() { + Expect((&Kinesis{}).Close(nil)).To(BeNil()) + }) + }) +}) diff --git a/backends/awskinesis/display.go b/backends/awskinesis/display.go new file mode 100644 index 00000000..67345fb7 --- /dev/null +++ b/backends/awskinesis/display.go @@ -0,0 +1,51 @@ +package awskinesis + +import ( + "time" + + "github.com/pkg/errors" + + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + "github.com/batchcorp/plumber-schemas/build/go/protos/records" + "github.com/batchcorp/plumber/printer" +) + +// DisplayMessage will parse a Read record and print (pretty) output to STDOUT +func (k *Kinesis) DisplayMessage(cliOpts *opts.CLIOptions, msg *records.ReadRecord) error { + if err := validateReadRecord(msg); err != nil { + return errors.Wrap(err, "unable to validate read record") + } + + record := msg.GetAwsKinesis() + + properties := [][]string{ + {"Partition Key", record.PartitionKey}, + {"Sequence Number", record.SequenceNumber}, + {"Encryption Type", record.EncryptionType}, + {"Shard ID", record.ShardId}, + } + + receivedAt := time.Unix(msg.ReceivedAtUnixTsUtc, 0) + + printer.PrintTable(cliOpts, msg.Num, receivedAt, msg.Payload, properties) + + return nil +} + +// DisplayError will parse an Error record and print (pretty) output to STDOUT +func (k *Kinesis) DisplayError(msg *records.ErrorRecord) error { + printer.DefaultDisplayError(msg) + return nil +} + +func validateReadRecord(msg *records.ReadRecord) error { + if msg == nil { + return errors.New("msg cannot be nil") + } + + if msg.GetAwsKinesis().Value == nil { + return errors.New("message value cannot be nil") + } + + return nil +} diff --git a/backends/awskinesis/dynamic.go b/backends/awskinesis/dynamic.go new file mode 100644 index 00000000..f9aefaf7 --- /dev/null +++ b/backends/awskinesis/dynamic.go @@ -0,0 +1,77 @@ +package awskinesis + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/kinesis" + "github.com/pkg/errors" + + "github.com/batchcorp/plumber/validate" + + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + "github.com/batchcorp/plumber/dynamic" +) + +func (k *Kinesis) Dynamic(ctx context.Context, dynamicOpts *opts.DynamicOptions, dynamicSvc dynamic.IDynamic) error { + if err := validateDynamicOptions(dynamicOpts); err != nil { + return errors.Wrap(err, "unable to validate dynamic options") + } + + llog := k.log.WithField("pkg", "kinesis/dynamic") + + go dynamicSvc.Start("AWS Kinesis") + + outboundCh := dynamicSvc.Read() + + args := dynamicOpts.AwsKinesis.Args + + // Continually loop looking for messages on the channel. + for { + select { + case outbound := <-outboundCh: + putOpts := &kinesis.PutRecordInput{ + Data: outbound.Blob, + PartitionKey: aws.String(args.PartitionKey), + StreamName: aws.String(args.Stream), + } + + if _, err := k.client.PutRecord(putOpts); err != nil { + k.log.Errorf("Unable to replay message: %s", err) + break + } + + k.log.Debugf("Replayed message to Kinesis stream '%s' for replay '%s'", args.Stream, outbound.ReplayId) + case <-ctx.Done(): + llog.Warning("context cancelled") + return nil + } + } + + return nil +} + +func validateDynamicOptions(dynamicOpts *opts.DynamicOptions) error { + if dynamicOpts == nil { + return validate.ErrEmptyDynamicOpts + } + + if dynamicOpts.AwsKinesis == nil { + return validate.ErrEmptyBackendGroup + } + + args := dynamicOpts.AwsKinesis.Args + if args == nil { + return validate.ErrEmptyBackendArgs + } + + if args.Stream == "" { + return ErrEmptyStream + } + + if args.PartitionKey == "" { + return ErrEmptyPartitionKey + } + + return nil +} diff --git a/backends/awskinesis/dynamic_test.go b/backends/awskinesis/dynamic_test.go new file mode 100644 index 00000000..46ea2dac --- /dev/null +++ b/backends/awskinesis/dynamic_test.go @@ -0,0 +1,110 @@ +package awskinesis + +import ( + "context" + "io/ioutil" + + "github.com/aws/aws-sdk-go/service/kinesis" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/sirupsen/logrus" + + "github.com/batchcorp/collector-schemas/build/go/protos/events" + "github.com/batchcorp/plumber-schemas/build/go/protos/args" + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + + "github.com/batchcorp/plumber/backends/awskinesis/kinesisfakes" + "github.com/batchcorp/plumber/dynamic/dynamicfakes" + "github.com/batchcorp/plumber/validate" +) + +var _ = Describe("AWS Kinesis Backend", func() { + var dynamicOpts *opts.DynamicOptions + + BeforeEach(func() { + dynamicOpts = &opts.DynamicOptions{ + AwsKinesis: &opts.DynamicGroupAWSKinesisOptions{ + Args: &args.AWSKinesisWriteArgs{ + Stream: "test", + PartitionKey: "test", + SequenceNumber: "1", + }, + }, + } + }) + + Context("validateDynamicOptions", func() { + It("validates nil dynamic options", func() { + err := validateDynamicOptions(nil) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyDynamicOpts)) + }) + It("validates nil backend group", func() { + dynamicOpts.AwsKinesis = nil + err := validateDynamicOptions(dynamicOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyBackendGroup)) + }) + It("validates empty backend args", func() { + dynamicOpts.AwsKinesis.Args = nil + err := validateDynamicOptions(dynamicOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyBackendArgs)) + }) + It("validates empty topic", func() { + dynamicOpts.AwsKinesis.Args.Stream = "" + err := validateDynamicOptions(dynamicOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(ErrEmptyStream)) + }) + It("validates empty partition key", func() { + dynamicOpts.AwsKinesis.Args.PartitionKey = "" + err := validateDynamicOptions(dynamicOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(ErrEmptyPartitionKey)) + }) + It("passes validation", func() { + err := validateDynamicOptions(dynamicOpts) + Expect(err).ToNot(HaveOccurred()) + }) + }) + + Context("Dynamic", func() { + var fakeDynamic *dynamicfakes.FakeIDynamic + + BeforeEach(func() { + fakeDynamic = &dynamicfakes.FakeIDynamic{} + fakeDynamic.ReadStub = func() chan *events.Outbound { + ch := make(chan *events.Outbound, 1) + ch <- &events.Outbound{Blob: []byte(`testing`)} + return ch + } + }) + + It("validates dynamic options", func() { + err := (&Kinesis{}).Dynamic(context.Background(), nil, nil) + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring(validate.ErrEmptyDynamicOpts.Error())) + }) + + It("replays a message", func() { + ctx, cancel := context.WithCancel(context.Background()) + + fakeKinesis := &kinesisfakes.FakeKinesisAPI{} + fakeKinesis.PutRecordStub = func(*kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) { + defer cancel() + return &kinesis.PutRecordOutput{}, nil + } + + p := &Kinesis{ + client: fakeKinesis, + log: logrus.NewEntry(&logrus.Logger{Out: ioutil.Discard}), + } + + err := p.Dynamic(ctx, dynamicOpts, fakeDynamic) + Expect(err).ToNot(HaveOccurred()) + Expect(fakeDynamic.ReadCallCount()).To(Equal(1)) + Expect(fakeKinesis.PutRecordCallCount()).To(Equal(1)) + }) + }) +}) diff --git a/backends/awskinesis/kinesisfakes/fake_kinesis.go b/backends/awskinesis/kinesisfakes/fake_kinesis.go new file mode 100644 index 00000000..5f8c9433 --- /dev/null +++ b/backends/awskinesis/kinesisfakes/fake_kinesis.go @@ -0,0 +1,7560 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package kinesisfakes + +import ( + "context" + "sync" + + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/kinesis" + "github.com/aws/aws-sdk-go/service/kinesis/kinesisiface" +) + +type FakeKinesisAPI struct { + AddTagsToStreamStub func(*kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error) + addTagsToStreamMutex sync.RWMutex + addTagsToStreamArgsForCall []struct { + arg1 *kinesis.AddTagsToStreamInput + } + addTagsToStreamReturns struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + } + addTagsToStreamReturnsOnCall map[int]struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + } + AddTagsToStreamRequestStub func(*kinesis.AddTagsToStreamInput) (*request.Request, *kinesis.AddTagsToStreamOutput) + addTagsToStreamRequestMutex sync.RWMutex + addTagsToStreamRequestArgsForCall []struct { + arg1 *kinesis.AddTagsToStreamInput + } + addTagsToStreamRequestReturns struct { + result1 *request.Request + result2 *kinesis.AddTagsToStreamOutput + } + addTagsToStreamRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.AddTagsToStreamOutput + } + AddTagsToStreamWithContextStub func(context.Context, *kinesis.AddTagsToStreamInput, ...request.Option) (*kinesis.AddTagsToStreamOutput, error) + addTagsToStreamWithContextMutex sync.RWMutex + addTagsToStreamWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.AddTagsToStreamInput + arg3 []request.Option + } + addTagsToStreamWithContextReturns struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + } + addTagsToStreamWithContextReturnsOnCall map[int]struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + } + CreateStreamStub func(*kinesis.CreateStreamInput) (*kinesis.CreateStreamOutput, error) + createStreamMutex sync.RWMutex + createStreamArgsForCall []struct { + arg1 *kinesis.CreateStreamInput + } + createStreamReturns struct { + result1 *kinesis.CreateStreamOutput + result2 error + } + createStreamReturnsOnCall map[int]struct { + result1 *kinesis.CreateStreamOutput + result2 error + } + CreateStreamRequestStub func(*kinesis.CreateStreamInput) (*request.Request, *kinesis.CreateStreamOutput) + createStreamRequestMutex sync.RWMutex + createStreamRequestArgsForCall []struct { + arg1 *kinesis.CreateStreamInput + } + createStreamRequestReturns struct { + result1 *request.Request + result2 *kinesis.CreateStreamOutput + } + createStreamRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.CreateStreamOutput + } + CreateStreamWithContextStub func(context.Context, *kinesis.CreateStreamInput, ...request.Option) (*kinesis.CreateStreamOutput, error) + createStreamWithContextMutex sync.RWMutex + createStreamWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.CreateStreamInput + arg3 []request.Option + } + createStreamWithContextReturns struct { + result1 *kinesis.CreateStreamOutput + result2 error + } + createStreamWithContextReturnsOnCall map[int]struct { + result1 *kinesis.CreateStreamOutput + result2 error + } + DecreaseStreamRetentionPeriodStub func(*kinesis.DecreaseStreamRetentionPeriodInput) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) + decreaseStreamRetentionPeriodMutex sync.RWMutex + decreaseStreamRetentionPeriodArgsForCall []struct { + arg1 *kinesis.DecreaseStreamRetentionPeriodInput + } + decreaseStreamRetentionPeriodReturns struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + } + decreaseStreamRetentionPeriodReturnsOnCall map[int]struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + } + DecreaseStreamRetentionPeriodRequestStub func(*kinesis.DecreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.DecreaseStreamRetentionPeriodOutput) + decreaseStreamRetentionPeriodRequestMutex sync.RWMutex + decreaseStreamRetentionPeriodRequestArgsForCall []struct { + arg1 *kinesis.DecreaseStreamRetentionPeriodInput + } + decreaseStreamRetentionPeriodRequestReturns struct { + result1 *request.Request + result2 *kinesis.DecreaseStreamRetentionPeriodOutput + } + decreaseStreamRetentionPeriodRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.DecreaseStreamRetentionPeriodOutput + } + DecreaseStreamRetentionPeriodWithContextStub func(context.Context, *kinesis.DecreaseStreamRetentionPeriodInput, ...request.Option) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) + decreaseStreamRetentionPeriodWithContextMutex sync.RWMutex + decreaseStreamRetentionPeriodWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DecreaseStreamRetentionPeriodInput + arg3 []request.Option + } + decreaseStreamRetentionPeriodWithContextReturns struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + } + decreaseStreamRetentionPeriodWithContextReturnsOnCall map[int]struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + } + DeleteStreamStub func(*kinesis.DeleteStreamInput) (*kinesis.DeleteStreamOutput, error) + deleteStreamMutex sync.RWMutex + deleteStreamArgsForCall []struct { + arg1 *kinesis.DeleteStreamInput + } + deleteStreamReturns struct { + result1 *kinesis.DeleteStreamOutput + result2 error + } + deleteStreamReturnsOnCall map[int]struct { + result1 *kinesis.DeleteStreamOutput + result2 error + } + DeleteStreamRequestStub func(*kinesis.DeleteStreamInput) (*request.Request, *kinesis.DeleteStreamOutput) + deleteStreamRequestMutex sync.RWMutex + deleteStreamRequestArgsForCall []struct { + arg1 *kinesis.DeleteStreamInput + } + deleteStreamRequestReturns struct { + result1 *request.Request + result2 *kinesis.DeleteStreamOutput + } + deleteStreamRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.DeleteStreamOutput + } + DeleteStreamWithContextStub func(context.Context, *kinesis.DeleteStreamInput, ...request.Option) (*kinesis.DeleteStreamOutput, error) + deleteStreamWithContextMutex sync.RWMutex + deleteStreamWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DeleteStreamInput + arg3 []request.Option + } + deleteStreamWithContextReturns struct { + result1 *kinesis.DeleteStreamOutput + result2 error + } + deleteStreamWithContextReturnsOnCall map[int]struct { + result1 *kinesis.DeleteStreamOutput + result2 error + } + DeregisterStreamConsumerStub func(*kinesis.DeregisterStreamConsumerInput) (*kinesis.DeregisterStreamConsumerOutput, error) + deregisterStreamConsumerMutex sync.RWMutex + deregisterStreamConsumerArgsForCall []struct { + arg1 *kinesis.DeregisterStreamConsumerInput + } + deregisterStreamConsumerReturns struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + } + deregisterStreamConsumerReturnsOnCall map[int]struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + } + DeregisterStreamConsumerRequestStub func(*kinesis.DeregisterStreamConsumerInput) (*request.Request, *kinesis.DeregisterStreamConsumerOutput) + deregisterStreamConsumerRequestMutex sync.RWMutex + deregisterStreamConsumerRequestArgsForCall []struct { + arg1 *kinesis.DeregisterStreamConsumerInput + } + deregisterStreamConsumerRequestReturns struct { + result1 *request.Request + result2 *kinesis.DeregisterStreamConsumerOutput + } + deregisterStreamConsumerRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.DeregisterStreamConsumerOutput + } + DeregisterStreamConsumerWithContextStub func(context.Context, *kinesis.DeregisterStreamConsumerInput, ...request.Option) (*kinesis.DeregisterStreamConsumerOutput, error) + deregisterStreamConsumerWithContextMutex sync.RWMutex + deregisterStreamConsumerWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DeregisterStreamConsumerInput + arg3 []request.Option + } + deregisterStreamConsumerWithContextReturns struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + } + deregisterStreamConsumerWithContextReturnsOnCall map[int]struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + } + DescribeLimitsStub func(*kinesis.DescribeLimitsInput) (*kinesis.DescribeLimitsOutput, error) + describeLimitsMutex sync.RWMutex + describeLimitsArgsForCall []struct { + arg1 *kinesis.DescribeLimitsInput + } + describeLimitsReturns struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + } + describeLimitsReturnsOnCall map[int]struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + } + DescribeLimitsRequestStub func(*kinesis.DescribeLimitsInput) (*request.Request, *kinesis.DescribeLimitsOutput) + describeLimitsRequestMutex sync.RWMutex + describeLimitsRequestArgsForCall []struct { + arg1 *kinesis.DescribeLimitsInput + } + describeLimitsRequestReturns struct { + result1 *request.Request + result2 *kinesis.DescribeLimitsOutput + } + describeLimitsRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeLimitsOutput + } + DescribeLimitsWithContextStub func(context.Context, *kinesis.DescribeLimitsInput, ...request.Option) (*kinesis.DescribeLimitsOutput, error) + describeLimitsWithContextMutex sync.RWMutex + describeLimitsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DescribeLimitsInput + arg3 []request.Option + } + describeLimitsWithContextReturns struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + } + describeLimitsWithContextReturnsOnCall map[int]struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + } + DescribeStreamStub func(*kinesis.DescribeStreamInput) (*kinesis.DescribeStreamOutput, error) + describeStreamMutex sync.RWMutex + describeStreamArgsForCall []struct { + arg1 *kinesis.DescribeStreamInput + } + describeStreamReturns struct { + result1 *kinesis.DescribeStreamOutput + result2 error + } + describeStreamReturnsOnCall map[int]struct { + result1 *kinesis.DescribeStreamOutput + result2 error + } + DescribeStreamConsumerStub func(*kinesis.DescribeStreamConsumerInput) (*kinesis.DescribeStreamConsumerOutput, error) + describeStreamConsumerMutex sync.RWMutex + describeStreamConsumerArgsForCall []struct { + arg1 *kinesis.DescribeStreamConsumerInput + } + describeStreamConsumerReturns struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + } + describeStreamConsumerReturnsOnCall map[int]struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + } + DescribeStreamConsumerRequestStub func(*kinesis.DescribeStreamConsumerInput) (*request.Request, *kinesis.DescribeStreamConsumerOutput) + describeStreamConsumerRequestMutex sync.RWMutex + describeStreamConsumerRequestArgsForCall []struct { + arg1 *kinesis.DescribeStreamConsumerInput + } + describeStreamConsumerRequestReturns struct { + result1 *request.Request + result2 *kinesis.DescribeStreamConsumerOutput + } + describeStreamConsumerRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeStreamConsumerOutput + } + DescribeStreamConsumerWithContextStub func(context.Context, *kinesis.DescribeStreamConsumerInput, ...request.Option) (*kinesis.DescribeStreamConsumerOutput, error) + describeStreamConsumerWithContextMutex sync.RWMutex + describeStreamConsumerWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamConsumerInput + arg3 []request.Option + } + describeStreamConsumerWithContextReturns struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + } + describeStreamConsumerWithContextReturnsOnCall map[int]struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + } + DescribeStreamPagesStub func(*kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool) error + describeStreamPagesMutex sync.RWMutex + describeStreamPagesArgsForCall []struct { + arg1 *kinesis.DescribeStreamInput + arg2 func(*kinesis.DescribeStreamOutput, bool) bool + } + describeStreamPagesReturns struct { + result1 error + } + describeStreamPagesReturnsOnCall map[int]struct { + result1 error + } + DescribeStreamPagesWithContextStub func(context.Context, *kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool, ...request.Option) error + describeStreamPagesWithContextMutex sync.RWMutex + describeStreamPagesWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 func(*kinesis.DescribeStreamOutput, bool) bool + arg4 []request.Option + } + describeStreamPagesWithContextReturns struct { + result1 error + } + describeStreamPagesWithContextReturnsOnCall map[int]struct { + result1 error + } + DescribeStreamRequestStub func(*kinesis.DescribeStreamInput) (*request.Request, *kinesis.DescribeStreamOutput) + describeStreamRequestMutex sync.RWMutex + describeStreamRequestArgsForCall []struct { + arg1 *kinesis.DescribeStreamInput + } + describeStreamRequestReturns struct { + result1 *request.Request + result2 *kinesis.DescribeStreamOutput + } + describeStreamRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeStreamOutput + } + DescribeStreamSummaryStub func(*kinesis.DescribeStreamSummaryInput) (*kinesis.DescribeStreamSummaryOutput, error) + describeStreamSummaryMutex sync.RWMutex + describeStreamSummaryArgsForCall []struct { + arg1 *kinesis.DescribeStreamSummaryInput + } + describeStreamSummaryReturns struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + } + describeStreamSummaryReturnsOnCall map[int]struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + } + DescribeStreamSummaryRequestStub func(*kinesis.DescribeStreamSummaryInput) (*request.Request, *kinesis.DescribeStreamSummaryOutput) + describeStreamSummaryRequestMutex sync.RWMutex + describeStreamSummaryRequestArgsForCall []struct { + arg1 *kinesis.DescribeStreamSummaryInput + } + describeStreamSummaryRequestReturns struct { + result1 *request.Request + result2 *kinesis.DescribeStreamSummaryOutput + } + describeStreamSummaryRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeStreamSummaryOutput + } + DescribeStreamSummaryWithContextStub func(context.Context, *kinesis.DescribeStreamSummaryInput, ...request.Option) (*kinesis.DescribeStreamSummaryOutput, error) + describeStreamSummaryWithContextMutex sync.RWMutex + describeStreamSummaryWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamSummaryInput + arg3 []request.Option + } + describeStreamSummaryWithContextReturns struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + } + describeStreamSummaryWithContextReturnsOnCall map[int]struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + } + DescribeStreamWithContextStub func(context.Context, *kinesis.DescribeStreamInput, ...request.Option) (*kinesis.DescribeStreamOutput, error) + describeStreamWithContextMutex sync.RWMutex + describeStreamWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 []request.Option + } + describeStreamWithContextReturns struct { + result1 *kinesis.DescribeStreamOutput + result2 error + } + describeStreamWithContextReturnsOnCall map[int]struct { + result1 *kinesis.DescribeStreamOutput + result2 error + } + DisableEnhancedMonitoringStub func(*kinesis.DisableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) + disableEnhancedMonitoringMutex sync.RWMutex + disableEnhancedMonitoringArgsForCall []struct { + arg1 *kinesis.DisableEnhancedMonitoringInput + } + disableEnhancedMonitoringReturns struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + disableEnhancedMonitoringReturnsOnCall map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + DisableEnhancedMonitoringRequestStub func(*kinesis.DisableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) + disableEnhancedMonitoringRequestMutex sync.RWMutex + disableEnhancedMonitoringRequestArgsForCall []struct { + arg1 *kinesis.DisableEnhancedMonitoringInput + } + disableEnhancedMonitoringRequestReturns struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + } + disableEnhancedMonitoringRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + } + DisableEnhancedMonitoringWithContextStub func(context.Context, *kinesis.DisableEnhancedMonitoringInput, ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) + disableEnhancedMonitoringWithContextMutex sync.RWMutex + disableEnhancedMonitoringWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DisableEnhancedMonitoringInput + arg3 []request.Option + } + disableEnhancedMonitoringWithContextReturns struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + disableEnhancedMonitoringWithContextReturnsOnCall map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + EnableEnhancedMonitoringStub func(*kinesis.EnableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) + enableEnhancedMonitoringMutex sync.RWMutex + enableEnhancedMonitoringArgsForCall []struct { + arg1 *kinesis.EnableEnhancedMonitoringInput + } + enableEnhancedMonitoringReturns struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + enableEnhancedMonitoringReturnsOnCall map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + EnableEnhancedMonitoringRequestStub func(*kinesis.EnableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) + enableEnhancedMonitoringRequestMutex sync.RWMutex + enableEnhancedMonitoringRequestArgsForCall []struct { + arg1 *kinesis.EnableEnhancedMonitoringInput + } + enableEnhancedMonitoringRequestReturns struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + } + enableEnhancedMonitoringRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + } + EnableEnhancedMonitoringWithContextStub func(context.Context, *kinesis.EnableEnhancedMonitoringInput, ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) + enableEnhancedMonitoringWithContextMutex sync.RWMutex + enableEnhancedMonitoringWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.EnableEnhancedMonitoringInput + arg3 []request.Option + } + enableEnhancedMonitoringWithContextReturns struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + enableEnhancedMonitoringWithContextReturnsOnCall map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + } + GetRecordsStub func(*kinesis.GetRecordsInput) (*kinesis.GetRecordsOutput, error) + getRecordsMutex sync.RWMutex + getRecordsArgsForCall []struct { + arg1 *kinesis.GetRecordsInput + } + getRecordsReturns struct { + result1 *kinesis.GetRecordsOutput + result2 error + } + getRecordsReturnsOnCall map[int]struct { + result1 *kinesis.GetRecordsOutput + result2 error + } + GetRecordsRequestStub func(*kinesis.GetRecordsInput) (*request.Request, *kinesis.GetRecordsOutput) + getRecordsRequestMutex sync.RWMutex + getRecordsRequestArgsForCall []struct { + arg1 *kinesis.GetRecordsInput + } + getRecordsRequestReturns struct { + result1 *request.Request + result2 *kinesis.GetRecordsOutput + } + getRecordsRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.GetRecordsOutput + } + GetRecordsWithContextStub func(context.Context, *kinesis.GetRecordsInput, ...request.Option) (*kinesis.GetRecordsOutput, error) + getRecordsWithContextMutex sync.RWMutex + getRecordsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.GetRecordsInput + arg3 []request.Option + } + getRecordsWithContextReturns struct { + result1 *kinesis.GetRecordsOutput + result2 error + } + getRecordsWithContextReturnsOnCall map[int]struct { + result1 *kinesis.GetRecordsOutput + result2 error + } + GetShardIteratorStub func(*kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error) + getShardIteratorMutex sync.RWMutex + getShardIteratorArgsForCall []struct { + arg1 *kinesis.GetShardIteratorInput + } + getShardIteratorReturns struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + } + getShardIteratorReturnsOnCall map[int]struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + } + GetShardIteratorRequestStub func(*kinesis.GetShardIteratorInput) (*request.Request, *kinesis.GetShardIteratorOutput) + getShardIteratorRequestMutex sync.RWMutex + getShardIteratorRequestArgsForCall []struct { + arg1 *kinesis.GetShardIteratorInput + } + getShardIteratorRequestReturns struct { + result1 *request.Request + result2 *kinesis.GetShardIteratorOutput + } + getShardIteratorRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.GetShardIteratorOutput + } + GetShardIteratorWithContextStub func(context.Context, *kinesis.GetShardIteratorInput, ...request.Option) (*kinesis.GetShardIteratorOutput, error) + getShardIteratorWithContextMutex sync.RWMutex + getShardIteratorWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.GetShardIteratorInput + arg3 []request.Option + } + getShardIteratorWithContextReturns struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + } + getShardIteratorWithContextReturnsOnCall map[int]struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + } + IncreaseStreamRetentionPeriodStub func(*kinesis.IncreaseStreamRetentionPeriodInput) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) + increaseStreamRetentionPeriodMutex sync.RWMutex + increaseStreamRetentionPeriodArgsForCall []struct { + arg1 *kinesis.IncreaseStreamRetentionPeriodInput + } + increaseStreamRetentionPeriodReturns struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + } + increaseStreamRetentionPeriodReturnsOnCall map[int]struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + } + IncreaseStreamRetentionPeriodRequestStub func(*kinesis.IncreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.IncreaseStreamRetentionPeriodOutput) + increaseStreamRetentionPeriodRequestMutex sync.RWMutex + increaseStreamRetentionPeriodRequestArgsForCall []struct { + arg1 *kinesis.IncreaseStreamRetentionPeriodInput + } + increaseStreamRetentionPeriodRequestReturns struct { + result1 *request.Request + result2 *kinesis.IncreaseStreamRetentionPeriodOutput + } + increaseStreamRetentionPeriodRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.IncreaseStreamRetentionPeriodOutput + } + IncreaseStreamRetentionPeriodWithContextStub func(context.Context, *kinesis.IncreaseStreamRetentionPeriodInput, ...request.Option) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) + increaseStreamRetentionPeriodWithContextMutex sync.RWMutex + increaseStreamRetentionPeriodWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.IncreaseStreamRetentionPeriodInput + arg3 []request.Option + } + increaseStreamRetentionPeriodWithContextReturns struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + } + increaseStreamRetentionPeriodWithContextReturnsOnCall map[int]struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + } + ListShardsStub func(*kinesis.ListShardsInput) (*kinesis.ListShardsOutput, error) + listShardsMutex sync.RWMutex + listShardsArgsForCall []struct { + arg1 *kinesis.ListShardsInput + } + listShardsReturns struct { + result1 *kinesis.ListShardsOutput + result2 error + } + listShardsReturnsOnCall map[int]struct { + result1 *kinesis.ListShardsOutput + result2 error + } + ListShardsRequestStub func(*kinesis.ListShardsInput) (*request.Request, *kinesis.ListShardsOutput) + listShardsRequestMutex sync.RWMutex + listShardsRequestArgsForCall []struct { + arg1 *kinesis.ListShardsInput + } + listShardsRequestReturns struct { + result1 *request.Request + result2 *kinesis.ListShardsOutput + } + listShardsRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.ListShardsOutput + } + ListShardsWithContextStub func(context.Context, *kinesis.ListShardsInput, ...request.Option) (*kinesis.ListShardsOutput, error) + listShardsWithContextMutex sync.RWMutex + listShardsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.ListShardsInput + arg3 []request.Option + } + listShardsWithContextReturns struct { + result1 *kinesis.ListShardsOutput + result2 error + } + listShardsWithContextReturnsOnCall map[int]struct { + result1 *kinesis.ListShardsOutput + result2 error + } + ListStreamConsumersStub func(*kinesis.ListStreamConsumersInput) (*kinesis.ListStreamConsumersOutput, error) + listStreamConsumersMutex sync.RWMutex + listStreamConsumersArgsForCall []struct { + arg1 *kinesis.ListStreamConsumersInput + } + listStreamConsumersReturns struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + } + listStreamConsumersReturnsOnCall map[int]struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + } + ListStreamConsumersPagesStub func(*kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool) error + listStreamConsumersPagesMutex sync.RWMutex + listStreamConsumersPagesArgsForCall []struct { + arg1 *kinesis.ListStreamConsumersInput + arg2 func(*kinesis.ListStreamConsumersOutput, bool) bool + } + listStreamConsumersPagesReturns struct { + result1 error + } + listStreamConsumersPagesReturnsOnCall map[int]struct { + result1 error + } + ListStreamConsumersPagesWithContextStub func(context.Context, *kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool, ...request.Option) error + listStreamConsumersPagesWithContextMutex sync.RWMutex + listStreamConsumersPagesWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.ListStreamConsumersInput + arg3 func(*kinesis.ListStreamConsumersOutput, bool) bool + arg4 []request.Option + } + listStreamConsumersPagesWithContextReturns struct { + result1 error + } + listStreamConsumersPagesWithContextReturnsOnCall map[int]struct { + result1 error + } + ListStreamConsumersRequestStub func(*kinesis.ListStreamConsumersInput) (*request.Request, *kinesis.ListStreamConsumersOutput) + listStreamConsumersRequestMutex sync.RWMutex + listStreamConsumersRequestArgsForCall []struct { + arg1 *kinesis.ListStreamConsumersInput + } + listStreamConsumersRequestReturns struct { + result1 *request.Request + result2 *kinesis.ListStreamConsumersOutput + } + listStreamConsumersRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.ListStreamConsumersOutput + } + ListStreamConsumersWithContextStub func(context.Context, *kinesis.ListStreamConsumersInput, ...request.Option) (*kinesis.ListStreamConsumersOutput, error) + listStreamConsumersWithContextMutex sync.RWMutex + listStreamConsumersWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.ListStreamConsumersInput + arg3 []request.Option + } + listStreamConsumersWithContextReturns struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + } + listStreamConsumersWithContextReturnsOnCall map[int]struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + } + ListStreamsStub func(*kinesis.ListStreamsInput) (*kinesis.ListStreamsOutput, error) + listStreamsMutex sync.RWMutex + listStreamsArgsForCall []struct { + arg1 *kinesis.ListStreamsInput + } + listStreamsReturns struct { + result1 *kinesis.ListStreamsOutput + result2 error + } + listStreamsReturnsOnCall map[int]struct { + result1 *kinesis.ListStreamsOutput + result2 error + } + ListStreamsPagesStub func(*kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool) error + listStreamsPagesMutex sync.RWMutex + listStreamsPagesArgsForCall []struct { + arg1 *kinesis.ListStreamsInput + arg2 func(*kinesis.ListStreamsOutput, bool) bool + } + listStreamsPagesReturns struct { + result1 error + } + listStreamsPagesReturnsOnCall map[int]struct { + result1 error + } + ListStreamsPagesWithContextStub func(context.Context, *kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool, ...request.Option) error + listStreamsPagesWithContextMutex sync.RWMutex + listStreamsPagesWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.ListStreamsInput + arg3 func(*kinesis.ListStreamsOutput, bool) bool + arg4 []request.Option + } + listStreamsPagesWithContextReturns struct { + result1 error + } + listStreamsPagesWithContextReturnsOnCall map[int]struct { + result1 error + } + ListStreamsRequestStub func(*kinesis.ListStreamsInput) (*request.Request, *kinesis.ListStreamsOutput) + listStreamsRequestMutex sync.RWMutex + listStreamsRequestArgsForCall []struct { + arg1 *kinesis.ListStreamsInput + } + listStreamsRequestReturns struct { + result1 *request.Request + result2 *kinesis.ListStreamsOutput + } + listStreamsRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.ListStreamsOutput + } + ListStreamsWithContextStub func(context.Context, *kinesis.ListStreamsInput, ...request.Option) (*kinesis.ListStreamsOutput, error) + listStreamsWithContextMutex sync.RWMutex + listStreamsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.ListStreamsInput + arg3 []request.Option + } + listStreamsWithContextReturns struct { + result1 *kinesis.ListStreamsOutput + result2 error + } + listStreamsWithContextReturnsOnCall map[int]struct { + result1 *kinesis.ListStreamsOutput + result2 error + } + ListTagsForStreamStub func(*kinesis.ListTagsForStreamInput) (*kinesis.ListTagsForStreamOutput, error) + listTagsForStreamMutex sync.RWMutex + listTagsForStreamArgsForCall []struct { + arg1 *kinesis.ListTagsForStreamInput + } + listTagsForStreamReturns struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + } + listTagsForStreamReturnsOnCall map[int]struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + } + ListTagsForStreamRequestStub func(*kinesis.ListTagsForStreamInput) (*request.Request, *kinesis.ListTagsForStreamOutput) + listTagsForStreamRequestMutex sync.RWMutex + listTagsForStreamRequestArgsForCall []struct { + arg1 *kinesis.ListTagsForStreamInput + } + listTagsForStreamRequestReturns struct { + result1 *request.Request + result2 *kinesis.ListTagsForStreamOutput + } + listTagsForStreamRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.ListTagsForStreamOutput + } + ListTagsForStreamWithContextStub func(context.Context, *kinesis.ListTagsForStreamInput, ...request.Option) (*kinesis.ListTagsForStreamOutput, error) + listTagsForStreamWithContextMutex sync.RWMutex + listTagsForStreamWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.ListTagsForStreamInput + arg3 []request.Option + } + listTagsForStreamWithContextReturns struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + } + listTagsForStreamWithContextReturnsOnCall map[int]struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + } + MergeShardsStub func(*kinesis.MergeShardsInput) (*kinesis.MergeShardsOutput, error) + mergeShardsMutex sync.RWMutex + mergeShardsArgsForCall []struct { + arg1 *kinesis.MergeShardsInput + } + mergeShardsReturns struct { + result1 *kinesis.MergeShardsOutput + result2 error + } + mergeShardsReturnsOnCall map[int]struct { + result1 *kinesis.MergeShardsOutput + result2 error + } + MergeShardsRequestStub func(*kinesis.MergeShardsInput) (*request.Request, *kinesis.MergeShardsOutput) + mergeShardsRequestMutex sync.RWMutex + mergeShardsRequestArgsForCall []struct { + arg1 *kinesis.MergeShardsInput + } + mergeShardsRequestReturns struct { + result1 *request.Request + result2 *kinesis.MergeShardsOutput + } + mergeShardsRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.MergeShardsOutput + } + MergeShardsWithContextStub func(context.Context, *kinesis.MergeShardsInput, ...request.Option) (*kinesis.MergeShardsOutput, error) + mergeShardsWithContextMutex sync.RWMutex + mergeShardsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.MergeShardsInput + arg3 []request.Option + } + mergeShardsWithContextReturns struct { + result1 *kinesis.MergeShardsOutput + result2 error + } + mergeShardsWithContextReturnsOnCall map[int]struct { + result1 *kinesis.MergeShardsOutput + result2 error + } + PutRecordStub func(*kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) + putRecordMutex sync.RWMutex + putRecordArgsForCall []struct { + arg1 *kinesis.PutRecordInput + } + putRecordReturns struct { + result1 *kinesis.PutRecordOutput + result2 error + } + putRecordReturnsOnCall map[int]struct { + result1 *kinesis.PutRecordOutput + result2 error + } + PutRecordRequestStub func(*kinesis.PutRecordInput) (*request.Request, *kinesis.PutRecordOutput) + putRecordRequestMutex sync.RWMutex + putRecordRequestArgsForCall []struct { + arg1 *kinesis.PutRecordInput + } + putRecordRequestReturns struct { + result1 *request.Request + result2 *kinesis.PutRecordOutput + } + putRecordRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.PutRecordOutput + } + PutRecordWithContextStub func(context.Context, *kinesis.PutRecordInput, ...request.Option) (*kinesis.PutRecordOutput, error) + putRecordWithContextMutex sync.RWMutex + putRecordWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.PutRecordInput + arg3 []request.Option + } + putRecordWithContextReturns struct { + result1 *kinesis.PutRecordOutput + result2 error + } + putRecordWithContextReturnsOnCall map[int]struct { + result1 *kinesis.PutRecordOutput + result2 error + } + PutRecordsStub func(*kinesis.PutRecordsInput) (*kinesis.PutRecordsOutput, error) + putRecordsMutex sync.RWMutex + putRecordsArgsForCall []struct { + arg1 *kinesis.PutRecordsInput + } + putRecordsReturns struct { + result1 *kinesis.PutRecordsOutput + result2 error + } + putRecordsReturnsOnCall map[int]struct { + result1 *kinesis.PutRecordsOutput + result2 error + } + PutRecordsRequestStub func(*kinesis.PutRecordsInput) (*request.Request, *kinesis.PutRecordsOutput) + putRecordsRequestMutex sync.RWMutex + putRecordsRequestArgsForCall []struct { + arg1 *kinesis.PutRecordsInput + } + putRecordsRequestReturns struct { + result1 *request.Request + result2 *kinesis.PutRecordsOutput + } + putRecordsRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.PutRecordsOutput + } + PutRecordsWithContextStub func(context.Context, *kinesis.PutRecordsInput, ...request.Option) (*kinesis.PutRecordsOutput, error) + putRecordsWithContextMutex sync.RWMutex + putRecordsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.PutRecordsInput + arg3 []request.Option + } + putRecordsWithContextReturns struct { + result1 *kinesis.PutRecordsOutput + result2 error + } + putRecordsWithContextReturnsOnCall map[int]struct { + result1 *kinesis.PutRecordsOutput + result2 error + } + RegisterStreamConsumerStub func(*kinesis.RegisterStreamConsumerInput) (*kinesis.RegisterStreamConsumerOutput, error) + registerStreamConsumerMutex sync.RWMutex + registerStreamConsumerArgsForCall []struct { + arg1 *kinesis.RegisterStreamConsumerInput + } + registerStreamConsumerReturns struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + } + registerStreamConsumerReturnsOnCall map[int]struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + } + RegisterStreamConsumerRequestStub func(*kinesis.RegisterStreamConsumerInput) (*request.Request, *kinesis.RegisterStreamConsumerOutput) + registerStreamConsumerRequestMutex sync.RWMutex + registerStreamConsumerRequestArgsForCall []struct { + arg1 *kinesis.RegisterStreamConsumerInput + } + registerStreamConsumerRequestReturns struct { + result1 *request.Request + result2 *kinesis.RegisterStreamConsumerOutput + } + registerStreamConsumerRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.RegisterStreamConsumerOutput + } + RegisterStreamConsumerWithContextStub func(context.Context, *kinesis.RegisterStreamConsumerInput, ...request.Option) (*kinesis.RegisterStreamConsumerOutput, error) + registerStreamConsumerWithContextMutex sync.RWMutex + registerStreamConsumerWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.RegisterStreamConsumerInput + arg3 []request.Option + } + registerStreamConsumerWithContextReturns struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + } + registerStreamConsumerWithContextReturnsOnCall map[int]struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + } + RemoveTagsFromStreamStub func(*kinesis.RemoveTagsFromStreamInput) (*kinesis.RemoveTagsFromStreamOutput, error) + removeTagsFromStreamMutex sync.RWMutex + removeTagsFromStreamArgsForCall []struct { + arg1 *kinesis.RemoveTagsFromStreamInput + } + removeTagsFromStreamReturns struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + } + removeTagsFromStreamReturnsOnCall map[int]struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + } + RemoveTagsFromStreamRequestStub func(*kinesis.RemoveTagsFromStreamInput) (*request.Request, *kinesis.RemoveTagsFromStreamOutput) + removeTagsFromStreamRequestMutex sync.RWMutex + removeTagsFromStreamRequestArgsForCall []struct { + arg1 *kinesis.RemoveTagsFromStreamInput + } + removeTagsFromStreamRequestReturns struct { + result1 *request.Request + result2 *kinesis.RemoveTagsFromStreamOutput + } + removeTagsFromStreamRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.RemoveTagsFromStreamOutput + } + RemoveTagsFromStreamWithContextStub func(context.Context, *kinesis.RemoveTagsFromStreamInput, ...request.Option) (*kinesis.RemoveTagsFromStreamOutput, error) + removeTagsFromStreamWithContextMutex sync.RWMutex + removeTagsFromStreamWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.RemoveTagsFromStreamInput + arg3 []request.Option + } + removeTagsFromStreamWithContextReturns struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + } + removeTagsFromStreamWithContextReturnsOnCall map[int]struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + } + SplitShardStub func(*kinesis.SplitShardInput) (*kinesis.SplitShardOutput, error) + splitShardMutex sync.RWMutex + splitShardArgsForCall []struct { + arg1 *kinesis.SplitShardInput + } + splitShardReturns struct { + result1 *kinesis.SplitShardOutput + result2 error + } + splitShardReturnsOnCall map[int]struct { + result1 *kinesis.SplitShardOutput + result2 error + } + SplitShardRequestStub func(*kinesis.SplitShardInput) (*request.Request, *kinesis.SplitShardOutput) + splitShardRequestMutex sync.RWMutex + splitShardRequestArgsForCall []struct { + arg1 *kinesis.SplitShardInput + } + splitShardRequestReturns struct { + result1 *request.Request + result2 *kinesis.SplitShardOutput + } + splitShardRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.SplitShardOutput + } + SplitShardWithContextStub func(context.Context, *kinesis.SplitShardInput, ...request.Option) (*kinesis.SplitShardOutput, error) + splitShardWithContextMutex sync.RWMutex + splitShardWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.SplitShardInput + arg3 []request.Option + } + splitShardWithContextReturns struct { + result1 *kinesis.SplitShardOutput + result2 error + } + splitShardWithContextReturnsOnCall map[int]struct { + result1 *kinesis.SplitShardOutput + result2 error + } + StartStreamEncryptionStub func(*kinesis.StartStreamEncryptionInput) (*kinesis.StartStreamEncryptionOutput, error) + startStreamEncryptionMutex sync.RWMutex + startStreamEncryptionArgsForCall []struct { + arg1 *kinesis.StartStreamEncryptionInput + } + startStreamEncryptionReturns struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + } + startStreamEncryptionReturnsOnCall map[int]struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + } + StartStreamEncryptionRequestStub func(*kinesis.StartStreamEncryptionInput) (*request.Request, *kinesis.StartStreamEncryptionOutput) + startStreamEncryptionRequestMutex sync.RWMutex + startStreamEncryptionRequestArgsForCall []struct { + arg1 *kinesis.StartStreamEncryptionInput + } + startStreamEncryptionRequestReturns struct { + result1 *request.Request + result2 *kinesis.StartStreamEncryptionOutput + } + startStreamEncryptionRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.StartStreamEncryptionOutput + } + StartStreamEncryptionWithContextStub func(context.Context, *kinesis.StartStreamEncryptionInput, ...request.Option) (*kinesis.StartStreamEncryptionOutput, error) + startStreamEncryptionWithContextMutex sync.RWMutex + startStreamEncryptionWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.StartStreamEncryptionInput + arg3 []request.Option + } + startStreamEncryptionWithContextReturns struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + } + startStreamEncryptionWithContextReturnsOnCall map[int]struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + } + StopStreamEncryptionStub func(*kinesis.StopStreamEncryptionInput) (*kinesis.StopStreamEncryptionOutput, error) + stopStreamEncryptionMutex sync.RWMutex + stopStreamEncryptionArgsForCall []struct { + arg1 *kinesis.StopStreamEncryptionInput + } + stopStreamEncryptionReturns struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + } + stopStreamEncryptionReturnsOnCall map[int]struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + } + StopStreamEncryptionRequestStub func(*kinesis.StopStreamEncryptionInput) (*request.Request, *kinesis.StopStreamEncryptionOutput) + stopStreamEncryptionRequestMutex sync.RWMutex + stopStreamEncryptionRequestArgsForCall []struct { + arg1 *kinesis.StopStreamEncryptionInput + } + stopStreamEncryptionRequestReturns struct { + result1 *request.Request + result2 *kinesis.StopStreamEncryptionOutput + } + stopStreamEncryptionRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.StopStreamEncryptionOutput + } + StopStreamEncryptionWithContextStub func(context.Context, *kinesis.StopStreamEncryptionInput, ...request.Option) (*kinesis.StopStreamEncryptionOutput, error) + stopStreamEncryptionWithContextMutex sync.RWMutex + stopStreamEncryptionWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.StopStreamEncryptionInput + arg3 []request.Option + } + stopStreamEncryptionWithContextReturns struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + } + stopStreamEncryptionWithContextReturnsOnCall map[int]struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + } + SubscribeToShardStub func(*kinesis.SubscribeToShardInput) (*kinesis.SubscribeToShardOutput, error) + subscribeToShardMutex sync.RWMutex + subscribeToShardArgsForCall []struct { + arg1 *kinesis.SubscribeToShardInput + } + subscribeToShardReturns struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + } + subscribeToShardReturnsOnCall map[int]struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + } + SubscribeToShardRequestStub func(*kinesis.SubscribeToShardInput) (*request.Request, *kinesis.SubscribeToShardOutput) + subscribeToShardRequestMutex sync.RWMutex + subscribeToShardRequestArgsForCall []struct { + arg1 *kinesis.SubscribeToShardInput + } + subscribeToShardRequestReturns struct { + result1 *request.Request + result2 *kinesis.SubscribeToShardOutput + } + subscribeToShardRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.SubscribeToShardOutput + } + SubscribeToShardWithContextStub func(context.Context, *kinesis.SubscribeToShardInput, ...request.Option) (*kinesis.SubscribeToShardOutput, error) + subscribeToShardWithContextMutex sync.RWMutex + subscribeToShardWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.SubscribeToShardInput + arg3 []request.Option + } + subscribeToShardWithContextReturns struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + } + subscribeToShardWithContextReturnsOnCall map[int]struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + } + UpdateShardCountStub func(*kinesis.UpdateShardCountInput) (*kinesis.UpdateShardCountOutput, error) + updateShardCountMutex sync.RWMutex + updateShardCountArgsForCall []struct { + arg1 *kinesis.UpdateShardCountInput + } + updateShardCountReturns struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + } + updateShardCountReturnsOnCall map[int]struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + } + UpdateShardCountRequestStub func(*kinesis.UpdateShardCountInput) (*request.Request, *kinesis.UpdateShardCountOutput) + updateShardCountRequestMutex sync.RWMutex + updateShardCountRequestArgsForCall []struct { + arg1 *kinesis.UpdateShardCountInput + } + updateShardCountRequestReturns struct { + result1 *request.Request + result2 *kinesis.UpdateShardCountOutput + } + updateShardCountRequestReturnsOnCall map[int]struct { + result1 *request.Request + result2 *kinesis.UpdateShardCountOutput + } + UpdateShardCountWithContextStub func(context.Context, *kinesis.UpdateShardCountInput, ...request.Option) (*kinesis.UpdateShardCountOutput, error) + updateShardCountWithContextMutex sync.RWMutex + updateShardCountWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.UpdateShardCountInput + arg3 []request.Option + } + updateShardCountWithContextReturns struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + } + updateShardCountWithContextReturnsOnCall map[int]struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + } + WaitUntilStreamExistsStub func(*kinesis.DescribeStreamInput) error + waitUntilStreamExistsMutex sync.RWMutex + waitUntilStreamExistsArgsForCall []struct { + arg1 *kinesis.DescribeStreamInput + } + waitUntilStreamExistsReturns struct { + result1 error + } + waitUntilStreamExistsReturnsOnCall map[int]struct { + result1 error + } + WaitUntilStreamExistsWithContextStub func(context.Context, *kinesis.DescribeStreamInput, ...request.WaiterOption) error + waitUntilStreamExistsWithContextMutex sync.RWMutex + waitUntilStreamExistsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 []request.WaiterOption + } + waitUntilStreamExistsWithContextReturns struct { + result1 error + } + waitUntilStreamExistsWithContextReturnsOnCall map[int]struct { + result1 error + } + WaitUntilStreamNotExistsStub func(*kinesis.DescribeStreamInput) error + waitUntilStreamNotExistsMutex sync.RWMutex + waitUntilStreamNotExistsArgsForCall []struct { + arg1 *kinesis.DescribeStreamInput + } + waitUntilStreamNotExistsReturns struct { + result1 error + } + waitUntilStreamNotExistsReturnsOnCall map[int]struct { + result1 error + } + WaitUntilStreamNotExistsWithContextStub func(context.Context, *kinesis.DescribeStreamInput, ...request.WaiterOption) error + waitUntilStreamNotExistsWithContextMutex sync.RWMutex + waitUntilStreamNotExistsWithContextArgsForCall []struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 []request.WaiterOption + } + waitUntilStreamNotExistsWithContextReturns struct { + result1 error + } + waitUntilStreamNotExistsWithContextReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeKinesisAPI) AddTagsToStream(arg1 *kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error) { + fake.addTagsToStreamMutex.Lock() + ret, specificReturn := fake.addTagsToStreamReturnsOnCall[len(fake.addTagsToStreamArgsForCall)] + fake.addTagsToStreamArgsForCall = append(fake.addTagsToStreamArgsForCall, struct { + arg1 *kinesis.AddTagsToStreamInput + }{arg1}) + stub := fake.AddTagsToStreamStub + fakeReturns := fake.addTagsToStreamReturns + fake.recordInvocation("AddTagsToStream", []interface{}{arg1}) + fake.addTagsToStreamMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) AddTagsToStreamCallCount() int { + fake.addTagsToStreamMutex.RLock() + defer fake.addTagsToStreamMutex.RUnlock() + return len(fake.addTagsToStreamArgsForCall) +} + +func (fake *FakeKinesisAPI) AddTagsToStreamCalls(stub func(*kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error)) { + fake.addTagsToStreamMutex.Lock() + defer fake.addTagsToStreamMutex.Unlock() + fake.AddTagsToStreamStub = stub +} + +func (fake *FakeKinesisAPI) AddTagsToStreamArgsForCall(i int) *kinesis.AddTagsToStreamInput { + fake.addTagsToStreamMutex.RLock() + defer fake.addTagsToStreamMutex.RUnlock() + argsForCall := fake.addTagsToStreamArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) AddTagsToStreamReturns(result1 *kinesis.AddTagsToStreamOutput, result2 error) { + fake.addTagsToStreamMutex.Lock() + defer fake.addTagsToStreamMutex.Unlock() + fake.AddTagsToStreamStub = nil + fake.addTagsToStreamReturns = struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) AddTagsToStreamReturnsOnCall(i int, result1 *kinesis.AddTagsToStreamOutput, result2 error) { + fake.addTagsToStreamMutex.Lock() + defer fake.addTagsToStreamMutex.Unlock() + fake.AddTagsToStreamStub = nil + if fake.addTagsToStreamReturnsOnCall == nil { + fake.addTagsToStreamReturnsOnCall = make(map[int]struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + }) + } + fake.addTagsToStreamReturnsOnCall[i] = struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) AddTagsToStreamRequest(arg1 *kinesis.AddTagsToStreamInput) (*request.Request, *kinesis.AddTagsToStreamOutput) { + fake.addTagsToStreamRequestMutex.Lock() + ret, specificReturn := fake.addTagsToStreamRequestReturnsOnCall[len(fake.addTagsToStreamRequestArgsForCall)] + fake.addTagsToStreamRequestArgsForCall = append(fake.addTagsToStreamRequestArgsForCall, struct { + arg1 *kinesis.AddTagsToStreamInput + }{arg1}) + stub := fake.AddTagsToStreamRequestStub + fakeReturns := fake.addTagsToStreamRequestReturns + fake.recordInvocation("AddTagsToStreamRequest", []interface{}{arg1}) + fake.addTagsToStreamRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) AddTagsToStreamRequestCallCount() int { + fake.addTagsToStreamRequestMutex.RLock() + defer fake.addTagsToStreamRequestMutex.RUnlock() + return len(fake.addTagsToStreamRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) AddTagsToStreamRequestCalls(stub func(*kinesis.AddTagsToStreamInput) (*request.Request, *kinesis.AddTagsToStreamOutput)) { + fake.addTagsToStreamRequestMutex.Lock() + defer fake.addTagsToStreamRequestMutex.Unlock() + fake.AddTagsToStreamRequestStub = stub +} + +func (fake *FakeKinesisAPI) AddTagsToStreamRequestArgsForCall(i int) *kinesis.AddTagsToStreamInput { + fake.addTagsToStreamRequestMutex.RLock() + defer fake.addTagsToStreamRequestMutex.RUnlock() + argsForCall := fake.addTagsToStreamRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) AddTagsToStreamRequestReturns(result1 *request.Request, result2 *kinesis.AddTagsToStreamOutput) { + fake.addTagsToStreamRequestMutex.Lock() + defer fake.addTagsToStreamRequestMutex.Unlock() + fake.AddTagsToStreamRequestStub = nil + fake.addTagsToStreamRequestReturns = struct { + result1 *request.Request + result2 *kinesis.AddTagsToStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) AddTagsToStreamRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.AddTagsToStreamOutput) { + fake.addTagsToStreamRequestMutex.Lock() + defer fake.addTagsToStreamRequestMutex.Unlock() + fake.AddTagsToStreamRequestStub = nil + if fake.addTagsToStreamRequestReturnsOnCall == nil { + fake.addTagsToStreamRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.AddTagsToStreamOutput + }) + } + fake.addTagsToStreamRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.AddTagsToStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) AddTagsToStreamWithContext(arg1 context.Context, arg2 *kinesis.AddTagsToStreamInput, arg3 ...request.Option) (*kinesis.AddTagsToStreamOutput, error) { + fake.addTagsToStreamWithContextMutex.Lock() + ret, specificReturn := fake.addTagsToStreamWithContextReturnsOnCall[len(fake.addTagsToStreamWithContextArgsForCall)] + fake.addTagsToStreamWithContextArgsForCall = append(fake.addTagsToStreamWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.AddTagsToStreamInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.AddTagsToStreamWithContextStub + fakeReturns := fake.addTagsToStreamWithContextReturns + fake.recordInvocation("AddTagsToStreamWithContext", []interface{}{arg1, arg2, arg3}) + fake.addTagsToStreamWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) AddTagsToStreamWithContextCallCount() int { + fake.addTagsToStreamWithContextMutex.RLock() + defer fake.addTagsToStreamWithContextMutex.RUnlock() + return len(fake.addTagsToStreamWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) AddTagsToStreamWithContextCalls(stub func(context.Context, *kinesis.AddTagsToStreamInput, ...request.Option) (*kinesis.AddTagsToStreamOutput, error)) { + fake.addTagsToStreamWithContextMutex.Lock() + defer fake.addTagsToStreamWithContextMutex.Unlock() + fake.AddTagsToStreamWithContextStub = stub +} + +func (fake *FakeKinesisAPI) AddTagsToStreamWithContextArgsForCall(i int) (context.Context, *kinesis.AddTagsToStreamInput, []request.Option) { + fake.addTagsToStreamWithContextMutex.RLock() + defer fake.addTagsToStreamWithContextMutex.RUnlock() + argsForCall := fake.addTagsToStreamWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) AddTagsToStreamWithContextReturns(result1 *kinesis.AddTagsToStreamOutput, result2 error) { + fake.addTagsToStreamWithContextMutex.Lock() + defer fake.addTagsToStreamWithContextMutex.Unlock() + fake.AddTagsToStreamWithContextStub = nil + fake.addTagsToStreamWithContextReturns = struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) AddTagsToStreamWithContextReturnsOnCall(i int, result1 *kinesis.AddTagsToStreamOutput, result2 error) { + fake.addTagsToStreamWithContextMutex.Lock() + defer fake.addTagsToStreamWithContextMutex.Unlock() + fake.AddTagsToStreamWithContextStub = nil + if fake.addTagsToStreamWithContextReturnsOnCall == nil { + fake.addTagsToStreamWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + }) + } + fake.addTagsToStreamWithContextReturnsOnCall[i] = struct { + result1 *kinesis.AddTagsToStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) CreateStream(arg1 *kinesis.CreateStreamInput) (*kinesis.CreateStreamOutput, error) { + fake.createStreamMutex.Lock() + ret, specificReturn := fake.createStreamReturnsOnCall[len(fake.createStreamArgsForCall)] + fake.createStreamArgsForCall = append(fake.createStreamArgsForCall, struct { + arg1 *kinesis.CreateStreamInput + }{arg1}) + stub := fake.CreateStreamStub + fakeReturns := fake.createStreamReturns + fake.recordInvocation("CreateStream", []interface{}{arg1}) + fake.createStreamMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) CreateStreamCallCount() int { + fake.createStreamMutex.RLock() + defer fake.createStreamMutex.RUnlock() + return len(fake.createStreamArgsForCall) +} + +func (fake *FakeKinesisAPI) CreateStreamCalls(stub func(*kinesis.CreateStreamInput) (*kinesis.CreateStreamOutput, error)) { + fake.createStreamMutex.Lock() + defer fake.createStreamMutex.Unlock() + fake.CreateStreamStub = stub +} + +func (fake *FakeKinesisAPI) CreateStreamArgsForCall(i int) *kinesis.CreateStreamInput { + fake.createStreamMutex.RLock() + defer fake.createStreamMutex.RUnlock() + argsForCall := fake.createStreamArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) CreateStreamReturns(result1 *kinesis.CreateStreamOutput, result2 error) { + fake.createStreamMutex.Lock() + defer fake.createStreamMutex.Unlock() + fake.CreateStreamStub = nil + fake.createStreamReturns = struct { + result1 *kinesis.CreateStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) CreateStreamReturnsOnCall(i int, result1 *kinesis.CreateStreamOutput, result2 error) { + fake.createStreamMutex.Lock() + defer fake.createStreamMutex.Unlock() + fake.CreateStreamStub = nil + if fake.createStreamReturnsOnCall == nil { + fake.createStreamReturnsOnCall = make(map[int]struct { + result1 *kinesis.CreateStreamOutput + result2 error + }) + } + fake.createStreamReturnsOnCall[i] = struct { + result1 *kinesis.CreateStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) CreateStreamRequest(arg1 *kinesis.CreateStreamInput) (*request.Request, *kinesis.CreateStreamOutput) { + fake.createStreamRequestMutex.Lock() + ret, specificReturn := fake.createStreamRequestReturnsOnCall[len(fake.createStreamRequestArgsForCall)] + fake.createStreamRequestArgsForCall = append(fake.createStreamRequestArgsForCall, struct { + arg1 *kinesis.CreateStreamInput + }{arg1}) + stub := fake.CreateStreamRequestStub + fakeReturns := fake.createStreamRequestReturns + fake.recordInvocation("CreateStreamRequest", []interface{}{arg1}) + fake.createStreamRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) CreateStreamRequestCallCount() int { + fake.createStreamRequestMutex.RLock() + defer fake.createStreamRequestMutex.RUnlock() + return len(fake.createStreamRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) CreateStreamRequestCalls(stub func(*kinesis.CreateStreamInput) (*request.Request, *kinesis.CreateStreamOutput)) { + fake.createStreamRequestMutex.Lock() + defer fake.createStreamRequestMutex.Unlock() + fake.CreateStreamRequestStub = stub +} + +func (fake *FakeKinesisAPI) CreateStreamRequestArgsForCall(i int) *kinesis.CreateStreamInput { + fake.createStreamRequestMutex.RLock() + defer fake.createStreamRequestMutex.RUnlock() + argsForCall := fake.createStreamRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) CreateStreamRequestReturns(result1 *request.Request, result2 *kinesis.CreateStreamOutput) { + fake.createStreamRequestMutex.Lock() + defer fake.createStreamRequestMutex.Unlock() + fake.CreateStreamRequestStub = nil + fake.createStreamRequestReturns = struct { + result1 *request.Request + result2 *kinesis.CreateStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) CreateStreamRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.CreateStreamOutput) { + fake.createStreamRequestMutex.Lock() + defer fake.createStreamRequestMutex.Unlock() + fake.CreateStreamRequestStub = nil + if fake.createStreamRequestReturnsOnCall == nil { + fake.createStreamRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.CreateStreamOutput + }) + } + fake.createStreamRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.CreateStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) CreateStreamWithContext(arg1 context.Context, arg2 *kinesis.CreateStreamInput, arg3 ...request.Option) (*kinesis.CreateStreamOutput, error) { + fake.createStreamWithContextMutex.Lock() + ret, specificReturn := fake.createStreamWithContextReturnsOnCall[len(fake.createStreamWithContextArgsForCall)] + fake.createStreamWithContextArgsForCall = append(fake.createStreamWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.CreateStreamInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.CreateStreamWithContextStub + fakeReturns := fake.createStreamWithContextReturns + fake.recordInvocation("CreateStreamWithContext", []interface{}{arg1, arg2, arg3}) + fake.createStreamWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) CreateStreamWithContextCallCount() int { + fake.createStreamWithContextMutex.RLock() + defer fake.createStreamWithContextMutex.RUnlock() + return len(fake.createStreamWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) CreateStreamWithContextCalls(stub func(context.Context, *kinesis.CreateStreamInput, ...request.Option) (*kinesis.CreateStreamOutput, error)) { + fake.createStreamWithContextMutex.Lock() + defer fake.createStreamWithContextMutex.Unlock() + fake.CreateStreamWithContextStub = stub +} + +func (fake *FakeKinesisAPI) CreateStreamWithContextArgsForCall(i int) (context.Context, *kinesis.CreateStreamInput, []request.Option) { + fake.createStreamWithContextMutex.RLock() + defer fake.createStreamWithContextMutex.RUnlock() + argsForCall := fake.createStreamWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) CreateStreamWithContextReturns(result1 *kinesis.CreateStreamOutput, result2 error) { + fake.createStreamWithContextMutex.Lock() + defer fake.createStreamWithContextMutex.Unlock() + fake.CreateStreamWithContextStub = nil + fake.createStreamWithContextReturns = struct { + result1 *kinesis.CreateStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) CreateStreamWithContextReturnsOnCall(i int, result1 *kinesis.CreateStreamOutput, result2 error) { + fake.createStreamWithContextMutex.Lock() + defer fake.createStreamWithContextMutex.Unlock() + fake.CreateStreamWithContextStub = nil + if fake.createStreamWithContextReturnsOnCall == nil { + fake.createStreamWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.CreateStreamOutput + result2 error + }) + } + fake.createStreamWithContextReturnsOnCall[i] = struct { + result1 *kinesis.CreateStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriod(arg1 *kinesis.DecreaseStreamRetentionPeriodInput) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) { + fake.decreaseStreamRetentionPeriodMutex.Lock() + ret, specificReturn := fake.decreaseStreamRetentionPeriodReturnsOnCall[len(fake.decreaseStreamRetentionPeriodArgsForCall)] + fake.decreaseStreamRetentionPeriodArgsForCall = append(fake.decreaseStreamRetentionPeriodArgsForCall, struct { + arg1 *kinesis.DecreaseStreamRetentionPeriodInput + }{arg1}) + stub := fake.DecreaseStreamRetentionPeriodStub + fakeReturns := fake.decreaseStreamRetentionPeriodReturns + fake.recordInvocation("DecreaseStreamRetentionPeriod", []interface{}{arg1}) + fake.decreaseStreamRetentionPeriodMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodCallCount() int { + fake.decreaseStreamRetentionPeriodMutex.RLock() + defer fake.decreaseStreamRetentionPeriodMutex.RUnlock() + return len(fake.decreaseStreamRetentionPeriodArgsForCall) +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodCalls(stub func(*kinesis.DecreaseStreamRetentionPeriodInput) (*kinesis.DecreaseStreamRetentionPeriodOutput, error)) { + fake.decreaseStreamRetentionPeriodMutex.Lock() + defer fake.decreaseStreamRetentionPeriodMutex.Unlock() + fake.DecreaseStreamRetentionPeriodStub = stub +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodArgsForCall(i int) *kinesis.DecreaseStreamRetentionPeriodInput { + fake.decreaseStreamRetentionPeriodMutex.RLock() + defer fake.decreaseStreamRetentionPeriodMutex.RUnlock() + argsForCall := fake.decreaseStreamRetentionPeriodArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodReturns(result1 *kinesis.DecreaseStreamRetentionPeriodOutput, result2 error) { + fake.decreaseStreamRetentionPeriodMutex.Lock() + defer fake.decreaseStreamRetentionPeriodMutex.Unlock() + fake.DecreaseStreamRetentionPeriodStub = nil + fake.decreaseStreamRetentionPeriodReturns = struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodReturnsOnCall(i int, result1 *kinesis.DecreaseStreamRetentionPeriodOutput, result2 error) { + fake.decreaseStreamRetentionPeriodMutex.Lock() + defer fake.decreaseStreamRetentionPeriodMutex.Unlock() + fake.DecreaseStreamRetentionPeriodStub = nil + if fake.decreaseStreamRetentionPeriodReturnsOnCall == nil { + fake.decreaseStreamRetentionPeriodReturnsOnCall = make(map[int]struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + }) + } + fake.decreaseStreamRetentionPeriodReturnsOnCall[i] = struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodRequest(arg1 *kinesis.DecreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.DecreaseStreamRetentionPeriodOutput) { + fake.decreaseStreamRetentionPeriodRequestMutex.Lock() + ret, specificReturn := fake.decreaseStreamRetentionPeriodRequestReturnsOnCall[len(fake.decreaseStreamRetentionPeriodRequestArgsForCall)] + fake.decreaseStreamRetentionPeriodRequestArgsForCall = append(fake.decreaseStreamRetentionPeriodRequestArgsForCall, struct { + arg1 *kinesis.DecreaseStreamRetentionPeriodInput + }{arg1}) + stub := fake.DecreaseStreamRetentionPeriodRequestStub + fakeReturns := fake.decreaseStreamRetentionPeriodRequestReturns + fake.recordInvocation("DecreaseStreamRetentionPeriodRequest", []interface{}{arg1}) + fake.decreaseStreamRetentionPeriodRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodRequestCallCount() int { + fake.decreaseStreamRetentionPeriodRequestMutex.RLock() + defer fake.decreaseStreamRetentionPeriodRequestMutex.RUnlock() + return len(fake.decreaseStreamRetentionPeriodRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodRequestCalls(stub func(*kinesis.DecreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.DecreaseStreamRetentionPeriodOutput)) { + fake.decreaseStreamRetentionPeriodRequestMutex.Lock() + defer fake.decreaseStreamRetentionPeriodRequestMutex.Unlock() + fake.DecreaseStreamRetentionPeriodRequestStub = stub +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodRequestArgsForCall(i int) *kinesis.DecreaseStreamRetentionPeriodInput { + fake.decreaseStreamRetentionPeriodRequestMutex.RLock() + defer fake.decreaseStreamRetentionPeriodRequestMutex.RUnlock() + argsForCall := fake.decreaseStreamRetentionPeriodRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodRequestReturns(result1 *request.Request, result2 *kinesis.DecreaseStreamRetentionPeriodOutput) { + fake.decreaseStreamRetentionPeriodRequestMutex.Lock() + defer fake.decreaseStreamRetentionPeriodRequestMutex.Unlock() + fake.DecreaseStreamRetentionPeriodRequestStub = nil + fake.decreaseStreamRetentionPeriodRequestReturns = struct { + result1 *request.Request + result2 *kinesis.DecreaseStreamRetentionPeriodOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.DecreaseStreamRetentionPeriodOutput) { + fake.decreaseStreamRetentionPeriodRequestMutex.Lock() + defer fake.decreaseStreamRetentionPeriodRequestMutex.Unlock() + fake.DecreaseStreamRetentionPeriodRequestStub = nil + if fake.decreaseStreamRetentionPeriodRequestReturnsOnCall == nil { + fake.decreaseStreamRetentionPeriodRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.DecreaseStreamRetentionPeriodOutput + }) + } + fake.decreaseStreamRetentionPeriodRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.DecreaseStreamRetentionPeriodOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodWithContext(arg1 context.Context, arg2 *kinesis.DecreaseStreamRetentionPeriodInput, arg3 ...request.Option) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) { + fake.decreaseStreamRetentionPeriodWithContextMutex.Lock() + ret, specificReturn := fake.decreaseStreamRetentionPeriodWithContextReturnsOnCall[len(fake.decreaseStreamRetentionPeriodWithContextArgsForCall)] + fake.decreaseStreamRetentionPeriodWithContextArgsForCall = append(fake.decreaseStreamRetentionPeriodWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DecreaseStreamRetentionPeriodInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DecreaseStreamRetentionPeriodWithContextStub + fakeReturns := fake.decreaseStreamRetentionPeriodWithContextReturns + fake.recordInvocation("DecreaseStreamRetentionPeriodWithContext", []interface{}{arg1, arg2, arg3}) + fake.decreaseStreamRetentionPeriodWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodWithContextCallCount() int { + fake.decreaseStreamRetentionPeriodWithContextMutex.RLock() + defer fake.decreaseStreamRetentionPeriodWithContextMutex.RUnlock() + return len(fake.decreaseStreamRetentionPeriodWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodWithContextCalls(stub func(context.Context, *kinesis.DecreaseStreamRetentionPeriodInput, ...request.Option) (*kinesis.DecreaseStreamRetentionPeriodOutput, error)) { + fake.decreaseStreamRetentionPeriodWithContextMutex.Lock() + defer fake.decreaseStreamRetentionPeriodWithContextMutex.Unlock() + fake.DecreaseStreamRetentionPeriodWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodWithContextArgsForCall(i int) (context.Context, *kinesis.DecreaseStreamRetentionPeriodInput, []request.Option) { + fake.decreaseStreamRetentionPeriodWithContextMutex.RLock() + defer fake.decreaseStreamRetentionPeriodWithContextMutex.RUnlock() + argsForCall := fake.decreaseStreamRetentionPeriodWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodWithContextReturns(result1 *kinesis.DecreaseStreamRetentionPeriodOutput, result2 error) { + fake.decreaseStreamRetentionPeriodWithContextMutex.Lock() + defer fake.decreaseStreamRetentionPeriodWithContextMutex.Unlock() + fake.DecreaseStreamRetentionPeriodWithContextStub = nil + fake.decreaseStreamRetentionPeriodWithContextReturns = struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DecreaseStreamRetentionPeriodWithContextReturnsOnCall(i int, result1 *kinesis.DecreaseStreamRetentionPeriodOutput, result2 error) { + fake.decreaseStreamRetentionPeriodWithContextMutex.Lock() + defer fake.decreaseStreamRetentionPeriodWithContextMutex.Unlock() + fake.DecreaseStreamRetentionPeriodWithContextStub = nil + if fake.decreaseStreamRetentionPeriodWithContextReturnsOnCall == nil { + fake.decreaseStreamRetentionPeriodWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + }) + } + fake.decreaseStreamRetentionPeriodWithContextReturnsOnCall[i] = struct { + result1 *kinesis.DecreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeleteStream(arg1 *kinesis.DeleteStreamInput) (*kinesis.DeleteStreamOutput, error) { + fake.deleteStreamMutex.Lock() + ret, specificReturn := fake.deleteStreamReturnsOnCall[len(fake.deleteStreamArgsForCall)] + fake.deleteStreamArgsForCall = append(fake.deleteStreamArgsForCall, struct { + arg1 *kinesis.DeleteStreamInput + }{arg1}) + stub := fake.DeleteStreamStub + fakeReturns := fake.deleteStreamReturns + fake.recordInvocation("DeleteStream", []interface{}{arg1}) + fake.deleteStreamMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DeleteStreamCallCount() int { + fake.deleteStreamMutex.RLock() + defer fake.deleteStreamMutex.RUnlock() + return len(fake.deleteStreamArgsForCall) +} + +func (fake *FakeKinesisAPI) DeleteStreamCalls(stub func(*kinesis.DeleteStreamInput) (*kinesis.DeleteStreamOutput, error)) { + fake.deleteStreamMutex.Lock() + defer fake.deleteStreamMutex.Unlock() + fake.DeleteStreamStub = stub +} + +func (fake *FakeKinesisAPI) DeleteStreamArgsForCall(i int) *kinesis.DeleteStreamInput { + fake.deleteStreamMutex.RLock() + defer fake.deleteStreamMutex.RUnlock() + argsForCall := fake.deleteStreamArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DeleteStreamReturns(result1 *kinesis.DeleteStreamOutput, result2 error) { + fake.deleteStreamMutex.Lock() + defer fake.deleteStreamMutex.Unlock() + fake.DeleteStreamStub = nil + fake.deleteStreamReturns = struct { + result1 *kinesis.DeleteStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeleteStreamReturnsOnCall(i int, result1 *kinesis.DeleteStreamOutput, result2 error) { + fake.deleteStreamMutex.Lock() + defer fake.deleteStreamMutex.Unlock() + fake.DeleteStreamStub = nil + if fake.deleteStreamReturnsOnCall == nil { + fake.deleteStreamReturnsOnCall = make(map[int]struct { + result1 *kinesis.DeleteStreamOutput + result2 error + }) + } + fake.deleteStreamReturnsOnCall[i] = struct { + result1 *kinesis.DeleteStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeleteStreamRequest(arg1 *kinesis.DeleteStreamInput) (*request.Request, *kinesis.DeleteStreamOutput) { + fake.deleteStreamRequestMutex.Lock() + ret, specificReturn := fake.deleteStreamRequestReturnsOnCall[len(fake.deleteStreamRequestArgsForCall)] + fake.deleteStreamRequestArgsForCall = append(fake.deleteStreamRequestArgsForCall, struct { + arg1 *kinesis.DeleteStreamInput + }{arg1}) + stub := fake.DeleteStreamRequestStub + fakeReturns := fake.deleteStreamRequestReturns + fake.recordInvocation("DeleteStreamRequest", []interface{}{arg1}) + fake.deleteStreamRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DeleteStreamRequestCallCount() int { + fake.deleteStreamRequestMutex.RLock() + defer fake.deleteStreamRequestMutex.RUnlock() + return len(fake.deleteStreamRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DeleteStreamRequestCalls(stub func(*kinesis.DeleteStreamInput) (*request.Request, *kinesis.DeleteStreamOutput)) { + fake.deleteStreamRequestMutex.Lock() + defer fake.deleteStreamRequestMutex.Unlock() + fake.DeleteStreamRequestStub = stub +} + +func (fake *FakeKinesisAPI) DeleteStreamRequestArgsForCall(i int) *kinesis.DeleteStreamInput { + fake.deleteStreamRequestMutex.RLock() + defer fake.deleteStreamRequestMutex.RUnlock() + argsForCall := fake.deleteStreamRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DeleteStreamRequestReturns(result1 *request.Request, result2 *kinesis.DeleteStreamOutput) { + fake.deleteStreamRequestMutex.Lock() + defer fake.deleteStreamRequestMutex.Unlock() + fake.DeleteStreamRequestStub = nil + fake.deleteStreamRequestReturns = struct { + result1 *request.Request + result2 *kinesis.DeleteStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeleteStreamRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.DeleteStreamOutput) { + fake.deleteStreamRequestMutex.Lock() + defer fake.deleteStreamRequestMutex.Unlock() + fake.DeleteStreamRequestStub = nil + if fake.deleteStreamRequestReturnsOnCall == nil { + fake.deleteStreamRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.DeleteStreamOutput + }) + } + fake.deleteStreamRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.DeleteStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeleteStreamWithContext(arg1 context.Context, arg2 *kinesis.DeleteStreamInput, arg3 ...request.Option) (*kinesis.DeleteStreamOutput, error) { + fake.deleteStreamWithContextMutex.Lock() + ret, specificReturn := fake.deleteStreamWithContextReturnsOnCall[len(fake.deleteStreamWithContextArgsForCall)] + fake.deleteStreamWithContextArgsForCall = append(fake.deleteStreamWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DeleteStreamInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DeleteStreamWithContextStub + fakeReturns := fake.deleteStreamWithContextReturns + fake.recordInvocation("DeleteStreamWithContext", []interface{}{arg1, arg2, arg3}) + fake.deleteStreamWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DeleteStreamWithContextCallCount() int { + fake.deleteStreamWithContextMutex.RLock() + defer fake.deleteStreamWithContextMutex.RUnlock() + return len(fake.deleteStreamWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DeleteStreamWithContextCalls(stub func(context.Context, *kinesis.DeleteStreamInput, ...request.Option) (*kinesis.DeleteStreamOutput, error)) { + fake.deleteStreamWithContextMutex.Lock() + defer fake.deleteStreamWithContextMutex.Unlock() + fake.DeleteStreamWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DeleteStreamWithContextArgsForCall(i int) (context.Context, *kinesis.DeleteStreamInput, []request.Option) { + fake.deleteStreamWithContextMutex.RLock() + defer fake.deleteStreamWithContextMutex.RUnlock() + argsForCall := fake.deleteStreamWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DeleteStreamWithContextReturns(result1 *kinesis.DeleteStreamOutput, result2 error) { + fake.deleteStreamWithContextMutex.Lock() + defer fake.deleteStreamWithContextMutex.Unlock() + fake.DeleteStreamWithContextStub = nil + fake.deleteStreamWithContextReturns = struct { + result1 *kinesis.DeleteStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeleteStreamWithContextReturnsOnCall(i int, result1 *kinesis.DeleteStreamOutput, result2 error) { + fake.deleteStreamWithContextMutex.Lock() + defer fake.deleteStreamWithContextMutex.Unlock() + fake.DeleteStreamWithContextStub = nil + if fake.deleteStreamWithContextReturnsOnCall == nil { + fake.deleteStreamWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.DeleteStreamOutput + result2 error + }) + } + fake.deleteStreamWithContextReturnsOnCall[i] = struct { + result1 *kinesis.DeleteStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumer(arg1 *kinesis.DeregisterStreamConsumerInput) (*kinesis.DeregisterStreamConsumerOutput, error) { + fake.deregisterStreamConsumerMutex.Lock() + ret, specificReturn := fake.deregisterStreamConsumerReturnsOnCall[len(fake.deregisterStreamConsumerArgsForCall)] + fake.deregisterStreamConsumerArgsForCall = append(fake.deregisterStreamConsumerArgsForCall, struct { + arg1 *kinesis.DeregisterStreamConsumerInput + }{arg1}) + stub := fake.DeregisterStreamConsumerStub + fakeReturns := fake.deregisterStreamConsumerReturns + fake.recordInvocation("DeregisterStreamConsumer", []interface{}{arg1}) + fake.deregisterStreamConsumerMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerCallCount() int { + fake.deregisterStreamConsumerMutex.RLock() + defer fake.deregisterStreamConsumerMutex.RUnlock() + return len(fake.deregisterStreamConsumerArgsForCall) +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerCalls(stub func(*kinesis.DeregisterStreamConsumerInput) (*kinesis.DeregisterStreamConsumerOutput, error)) { + fake.deregisterStreamConsumerMutex.Lock() + defer fake.deregisterStreamConsumerMutex.Unlock() + fake.DeregisterStreamConsumerStub = stub +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerArgsForCall(i int) *kinesis.DeregisterStreamConsumerInput { + fake.deregisterStreamConsumerMutex.RLock() + defer fake.deregisterStreamConsumerMutex.RUnlock() + argsForCall := fake.deregisterStreamConsumerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerReturns(result1 *kinesis.DeregisterStreamConsumerOutput, result2 error) { + fake.deregisterStreamConsumerMutex.Lock() + defer fake.deregisterStreamConsumerMutex.Unlock() + fake.DeregisterStreamConsumerStub = nil + fake.deregisterStreamConsumerReturns = struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerReturnsOnCall(i int, result1 *kinesis.DeregisterStreamConsumerOutput, result2 error) { + fake.deregisterStreamConsumerMutex.Lock() + defer fake.deregisterStreamConsumerMutex.Unlock() + fake.DeregisterStreamConsumerStub = nil + if fake.deregisterStreamConsumerReturnsOnCall == nil { + fake.deregisterStreamConsumerReturnsOnCall = make(map[int]struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + }) + } + fake.deregisterStreamConsumerReturnsOnCall[i] = struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerRequest(arg1 *kinesis.DeregisterStreamConsumerInput) (*request.Request, *kinesis.DeregisterStreamConsumerOutput) { + fake.deregisterStreamConsumerRequestMutex.Lock() + ret, specificReturn := fake.deregisterStreamConsumerRequestReturnsOnCall[len(fake.deregisterStreamConsumerRequestArgsForCall)] + fake.deregisterStreamConsumerRequestArgsForCall = append(fake.deregisterStreamConsumerRequestArgsForCall, struct { + arg1 *kinesis.DeregisterStreamConsumerInput + }{arg1}) + stub := fake.DeregisterStreamConsumerRequestStub + fakeReturns := fake.deregisterStreamConsumerRequestReturns + fake.recordInvocation("DeregisterStreamConsumerRequest", []interface{}{arg1}) + fake.deregisterStreamConsumerRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerRequestCallCount() int { + fake.deregisterStreamConsumerRequestMutex.RLock() + defer fake.deregisterStreamConsumerRequestMutex.RUnlock() + return len(fake.deregisterStreamConsumerRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerRequestCalls(stub func(*kinesis.DeregisterStreamConsumerInput) (*request.Request, *kinesis.DeregisterStreamConsumerOutput)) { + fake.deregisterStreamConsumerRequestMutex.Lock() + defer fake.deregisterStreamConsumerRequestMutex.Unlock() + fake.DeregisterStreamConsumerRequestStub = stub +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerRequestArgsForCall(i int) *kinesis.DeregisterStreamConsumerInput { + fake.deregisterStreamConsumerRequestMutex.RLock() + defer fake.deregisterStreamConsumerRequestMutex.RUnlock() + argsForCall := fake.deregisterStreamConsumerRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerRequestReturns(result1 *request.Request, result2 *kinesis.DeregisterStreamConsumerOutput) { + fake.deregisterStreamConsumerRequestMutex.Lock() + defer fake.deregisterStreamConsumerRequestMutex.Unlock() + fake.DeregisterStreamConsumerRequestStub = nil + fake.deregisterStreamConsumerRequestReturns = struct { + result1 *request.Request + result2 *kinesis.DeregisterStreamConsumerOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.DeregisterStreamConsumerOutput) { + fake.deregisterStreamConsumerRequestMutex.Lock() + defer fake.deregisterStreamConsumerRequestMutex.Unlock() + fake.DeregisterStreamConsumerRequestStub = nil + if fake.deregisterStreamConsumerRequestReturnsOnCall == nil { + fake.deregisterStreamConsumerRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.DeregisterStreamConsumerOutput + }) + } + fake.deregisterStreamConsumerRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.DeregisterStreamConsumerOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerWithContext(arg1 context.Context, arg2 *kinesis.DeregisterStreamConsumerInput, arg3 ...request.Option) (*kinesis.DeregisterStreamConsumerOutput, error) { + fake.deregisterStreamConsumerWithContextMutex.Lock() + ret, specificReturn := fake.deregisterStreamConsumerWithContextReturnsOnCall[len(fake.deregisterStreamConsumerWithContextArgsForCall)] + fake.deregisterStreamConsumerWithContextArgsForCall = append(fake.deregisterStreamConsumerWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DeregisterStreamConsumerInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DeregisterStreamConsumerWithContextStub + fakeReturns := fake.deregisterStreamConsumerWithContextReturns + fake.recordInvocation("DeregisterStreamConsumerWithContext", []interface{}{arg1, arg2, arg3}) + fake.deregisterStreamConsumerWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerWithContextCallCount() int { + fake.deregisterStreamConsumerWithContextMutex.RLock() + defer fake.deregisterStreamConsumerWithContextMutex.RUnlock() + return len(fake.deregisterStreamConsumerWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerWithContextCalls(stub func(context.Context, *kinesis.DeregisterStreamConsumerInput, ...request.Option) (*kinesis.DeregisterStreamConsumerOutput, error)) { + fake.deregisterStreamConsumerWithContextMutex.Lock() + defer fake.deregisterStreamConsumerWithContextMutex.Unlock() + fake.DeregisterStreamConsumerWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerWithContextArgsForCall(i int) (context.Context, *kinesis.DeregisterStreamConsumerInput, []request.Option) { + fake.deregisterStreamConsumerWithContextMutex.RLock() + defer fake.deregisterStreamConsumerWithContextMutex.RUnlock() + argsForCall := fake.deregisterStreamConsumerWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerWithContextReturns(result1 *kinesis.DeregisterStreamConsumerOutput, result2 error) { + fake.deregisterStreamConsumerWithContextMutex.Lock() + defer fake.deregisterStreamConsumerWithContextMutex.Unlock() + fake.DeregisterStreamConsumerWithContextStub = nil + fake.deregisterStreamConsumerWithContextReturns = struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DeregisterStreamConsumerWithContextReturnsOnCall(i int, result1 *kinesis.DeregisterStreamConsumerOutput, result2 error) { + fake.deregisterStreamConsumerWithContextMutex.Lock() + defer fake.deregisterStreamConsumerWithContextMutex.Unlock() + fake.DeregisterStreamConsumerWithContextStub = nil + if fake.deregisterStreamConsumerWithContextReturnsOnCall == nil { + fake.deregisterStreamConsumerWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + }) + } + fake.deregisterStreamConsumerWithContextReturnsOnCall[i] = struct { + result1 *kinesis.DeregisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeLimits(arg1 *kinesis.DescribeLimitsInput) (*kinesis.DescribeLimitsOutput, error) { + fake.describeLimitsMutex.Lock() + ret, specificReturn := fake.describeLimitsReturnsOnCall[len(fake.describeLimitsArgsForCall)] + fake.describeLimitsArgsForCall = append(fake.describeLimitsArgsForCall, struct { + arg1 *kinesis.DescribeLimitsInput + }{arg1}) + stub := fake.DescribeLimitsStub + fakeReturns := fake.describeLimitsReturns + fake.recordInvocation("DescribeLimits", []interface{}{arg1}) + fake.describeLimitsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeLimitsCallCount() int { + fake.describeLimitsMutex.RLock() + defer fake.describeLimitsMutex.RUnlock() + return len(fake.describeLimitsArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeLimitsCalls(stub func(*kinesis.DescribeLimitsInput) (*kinesis.DescribeLimitsOutput, error)) { + fake.describeLimitsMutex.Lock() + defer fake.describeLimitsMutex.Unlock() + fake.DescribeLimitsStub = stub +} + +func (fake *FakeKinesisAPI) DescribeLimitsArgsForCall(i int) *kinesis.DescribeLimitsInput { + fake.describeLimitsMutex.RLock() + defer fake.describeLimitsMutex.RUnlock() + argsForCall := fake.describeLimitsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeLimitsReturns(result1 *kinesis.DescribeLimitsOutput, result2 error) { + fake.describeLimitsMutex.Lock() + defer fake.describeLimitsMutex.Unlock() + fake.DescribeLimitsStub = nil + fake.describeLimitsReturns = struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeLimitsReturnsOnCall(i int, result1 *kinesis.DescribeLimitsOutput, result2 error) { + fake.describeLimitsMutex.Lock() + defer fake.describeLimitsMutex.Unlock() + fake.DescribeLimitsStub = nil + if fake.describeLimitsReturnsOnCall == nil { + fake.describeLimitsReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + }) + } + fake.describeLimitsReturnsOnCall[i] = struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeLimitsRequest(arg1 *kinesis.DescribeLimitsInput) (*request.Request, *kinesis.DescribeLimitsOutput) { + fake.describeLimitsRequestMutex.Lock() + ret, specificReturn := fake.describeLimitsRequestReturnsOnCall[len(fake.describeLimitsRequestArgsForCall)] + fake.describeLimitsRequestArgsForCall = append(fake.describeLimitsRequestArgsForCall, struct { + arg1 *kinesis.DescribeLimitsInput + }{arg1}) + stub := fake.DescribeLimitsRequestStub + fakeReturns := fake.describeLimitsRequestReturns + fake.recordInvocation("DescribeLimitsRequest", []interface{}{arg1}) + fake.describeLimitsRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeLimitsRequestCallCount() int { + fake.describeLimitsRequestMutex.RLock() + defer fake.describeLimitsRequestMutex.RUnlock() + return len(fake.describeLimitsRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeLimitsRequestCalls(stub func(*kinesis.DescribeLimitsInput) (*request.Request, *kinesis.DescribeLimitsOutput)) { + fake.describeLimitsRequestMutex.Lock() + defer fake.describeLimitsRequestMutex.Unlock() + fake.DescribeLimitsRequestStub = stub +} + +func (fake *FakeKinesisAPI) DescribeLimitsRequestArgsForCall(i int) *kinesis.DescribeLimitsInput { + fake.describeLimitsRequestMutex.RLock() + defer fake.describeLimitsRequestMutex.RUnlock() + argsForCall := fake.describeLimitsRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeLimitsRequestReturns(result1 *request.Request, result2 *kinesis.DescribeLimitsOutput) { + fake.describeLimitsRequestMutex.Lock() + defer fake.describeLimitsRequestMutex.Unlock() + fake.DescribeLimitsRequestStub = nil + fake.describeLimitsRequestReturns = struct { + result1 *request.Request + result2 *kinesis.DescribeLimitsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeLimitsRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.DescribeLimitsOutput) { + fake.describeLimitsRequestMutex.Lock() + defer fake.describeLimitsRequestMutex.Unlock() + fake.DescribeLimitsRequestStub = nil + if fake.describeLimitsRequestReturnsOnCall == nil { + fake.describeLimitsRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeLimitsOutput + }) + } + fake.describeLimitsRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.DescribeLimitsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeLimitsWithContext(arg1 context.Context, arg2 *kinesis.DescribeLimitsInput, arg3 ...request.Option) (*kinesis.DescribeLimitsOutput, error) { + fake.describeLimitsWithContextMutex.Lock() + ret, specificReturn := fake.describeLimitsWithContextReturnsOnCall[len(fake.describeLimitsWithContextArgsForCall)] + fake.describeLimitsWithContextArgsForCall = append(fake.describeLimitsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DescribeLimitsInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DescribeLimitsWithContextStub + fakeReturns := fake.describeLimitsWithContextReturns + fake.recordInvocation("DescribeLimitsWithContext", []interface{}{arg1, arg2, arg3}) + fake.describeLimitsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeLimitsWithContextCallCount() int { + fake.describeLimitsWithContextMutex.RLock() + defer fake.describeLimitsWithContextMutex.RUnlock() + return len(fake.describeLimitsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeLimitsWithContextCalls(stub func(context.Context, *kinesis.DescribeLimitsInput, ...request.Option) (*kinesis.DescribeLimitsOutput, error)) { + fake.describeLimitsWithContextMutex.Lock() + defer fake.describeLimitsWithContextMutex.Unlock() + fake.DescribeLimitsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DescribeLimitsWithContextArgsForCall(i int) (context.Context, *kinesis.DescribeLimitsInput, []request.Option) { + fake.describeLimitsWithContextMutex.RLock() + defer fake.describeLimitsWithContextMutex.RUnlock() + argsForCall := fake.describeLimitsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DescribeLimitsWithContextReturns(result1 *kinesis.DescribeLimitsOutput, result2 error) { + fake.describeLimitsWithContextMutex.Lock() + defer fake.describeLimitsWithContextMutex.Unlock() + fake.DescribeLimitsWithContextStub = nil + fake.describeLimitsWithContextReturns = struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeLimitsWithContextReturnsOnCall(i int, result1 *kinesis.DescribeLimitsOutput, result2 error) { + fake.describeLimitsWithContextMutex.Lock() + defer fake.describeLimitsWithContextMutex.Unlock() + fake.DescribeLimitsWithContextStub = nil + if fake.describeLimitsWithContextReturnsOnCall == nil { + fake.describeLimitsWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + }) + } + fake.describeLimitsWithContextReturnsOnCall[i] = struct { + result1 *kinesis.DescribeLimitsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStream(arg1 *kinesis.DescribeStreamInput) (*kinesis.DescribeStreamOutput, error) { + fake.describeStreamMutex.Lock() + ret, specificReturn := fake.describeStreamReturnsOnCall[len(fake.describeStreamArgsForCall)] + fake.describeStreamArgsForCall = append(fake.describeStreamArgsForCall, struct { + arg1 *kinesis.DescribeStreamInput + }{arg1}) + stub := fake.DescribeStreamStub + fakeReturns := fake.describeStreamReturns + fake.recordInvocation("DescribeStream", []interface{}{arg1}) + fake.describeStreamMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamCallCount() int { + fake.describeStreamMutex.RLock() + defer fake.describeStreamMutex.RUnlock() + return len(fake.describeStreamArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamCalls(stub func(*kinesis.DescribeStreamInput) (*kinesis.DescribeStreamOutput, error)) { + fake.describeStreamMutex.Lock() + defer fake.describeStreamMutex.Unlock() + fake.DescribeStreamStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamArgsForCall(i int) *kinesis.DescribeStreamInput { + fake.describeStreamMutex.RLock() + defer fake.describeStreamMutex.RUnlock() + argsForCall := fake.describeStreamArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeStreamReturns(result1 *kinesis.DescribeStreamOutput, result2 error) { + fake.describeStreamMutex.Lock() + defer fake.describeStreamMutex.Unlock() + fake.DescribeStreamStub = nil + fake.describeStreamReturns = struct { + result1 *kinesis.DescribeStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamReturnsOnCall(i int, result1 *kinesis.DescribeStreamOutput, result2 error) { + fake.describeStreamMutex.Lock() + defer fake.describeStreamMutex.Unlock() + fake.DescribeStreamStub = nil + if fake.describeStreamReturnsOnCall == nil { + fake.describeStreamReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeStreamOutput + result2 error + }) + } + fake.describeStreamReturnsOnCall[i] = struct { + result1 *kinesis.DescribeStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumer(arg1 *kinesis.DescribeStreamConsumerInput) (*kinesis.DescribeStreamConsumerOutput, error) { + fake.describeStreamConsumerMutex.Lock() + ret, specificReturn := fake.describeStreamConsumerReturnsOnCall[len(fake.describeStreamConsumerArgsForCall)] + fake.describeStreamConsumerArgsForCall = append(fake.describeStreamConsumerArgsForCall, struct { + arg1 *kinesis.DescribeStreamConsumerInput + }{arg1}) + stub := fake.DescribeStreamConsumerStub + fakeReturns := fake.describeStreamConsumerReturns + fake.recordInvocation("DescribeStreamConsumer", []interface{}{arg1}) + fake.describeStreamConsumerMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerCallCount() int { + fake.describeStreamConsumerMutex.RLock() + defer fake.describeStreamConsumerMutex.RUnlock() + return len(fake.describeStreamConsumerArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerCalls(stub func(*kinesis.DescribeStreamConsumerInput) (*kinesis.DescribeStreamConsumerOutput, error)) { + fake.describeStreamConsumerMutex.Lock() + defer fake.describeStreamConsumerMutex.Unlock() + fake.DescribeStreamConsumerStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerArgsForCall(i int) *kinesis.DescribeStreamConsumerInput { + fake.describeStreamConsumerMutex.RLock() + defer fake.describeStreamConsumerMutex.RUnlock() + argsForCall := fake.describeStreamConsumerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerReturns(result1 *kinesis.DescribeStreamConsumerOutput, result2 error) { + fake.describeStreamConsumerMutex.Lock() + defer fake.describeStreamConsumerMutex.Unlock() + fake.DescribeStreamConsumerStub = nil + fake.describeStreamConsumerReturns = struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerReturnsOnCall(i int, result1 *kinesis.DescribeStreamConsumerOutput, result2 error) { + fake.describeStreamConsumerMutex.Lock() + defer fake.describeStreamConsumerMutex.Unlock() + fake.DescribeStreamConsumerStub = nil + if fake.describeStreamConsumerReturnsOnCall == nil { + fake.describeStreamConsumerReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + }) + } + fake.describeStreamConsumerReturnsOnCall[i] = struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerRequest(arg1 *kinesis.DescribeStreamConsumerInput) (*request.Request, *kinesis.DescribeStreamConsumerOutput) { + fake.describeStreamConsumerRequestMutex.Lock() + ret, specificReturn := fake.describeStreamConsumerRequestReturnsOnCall[len(fake.describeStreamConsumerRequestArgsForCall)] + fake.describeStreamConsumerRequestArgsForCall = append(fake.describeStreamConsumerRequestArgsForCall, struct { + arg1 *kinesis.DescribeStreamConsumerInput + }{arg1}) + stub := fake.DescribeStreamConsumerRequestStub + fakeReturns := fake.describeStreamConsumerRequestReturns + fake.recordInvocation("DescribeStreamConsumerRequest", []interface{}{arg1}) + fake.describeStreamConsumerRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerRequestCallCount() int { + fake.describeStreamConsumerRequestMutex.RLock() + defer fake.describeStreamConsumerRequestMutex.RUnlock() + return len(fake.describeStreamConsumerRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerRequestCalls(stub func(*kinesis.DescribeStreamConsumerInput) (*request.Request, *kinesis.DescribeStreamConsumerOutput)) { + fake.describeStreamConsumerRequestMutex.Lock() + defer fake.describeStreamConsumerRequestMutex.Unlock() + fake.DescribeStreamConsumerRequestStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerRequestArgsForCall(i int) *kinesis.DescribeStreamConsumerInput { + fake.describeStreamConsumerRequestMutex.RLock() + defer fake.describeStreamConsumerRequestMutex.RUnlock() + argsForCall := fake.describeStreamConsumerRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerRequestReturns(result1 *request.Request, result2 *kinesis.DescribeStreamConsumerOutput) { + fake.describeStreamConsumerRequestMutex.Lock() + defer fake.describeStreamConsumerRequestMutex.Unlock() + fake.DescribeStreamConsumerRequestStub = nil + fake.describeStreamConsumerRequestReturns = struct { + result1 *request.Request + result2 *kinesis.DescribeStreamConsumerOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.DescribeStreamConsumerOutput) { + fake.describeStreamConsumerRequestMutex.Lock() + defer fake.describeStreamConsumerRequestMutex.Unlock() + fake.DescribeStreamConsumerRequestStub = nil + if fake.describeStreamConsumerRequestReturnsOnCall == nil { + fake.describeStreamConsumerRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeStreamConsumerOutput + }) + } + fake.describeStreamConsumerRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.DescribeStreamConsumerOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerWithContext(arg1 context.Context, arg2 *kinesis.DescribeStreamConsumerInput, arg3 ...request.Option) (*kinesis.DescribeStreamConsumerOutput, error) { + fake.describeStreamConsumerWithContextMutex.Lock() + ret, specificReturn := fake.describeStreamConsumerWithContextReturnsOnCall[len(fake.describeStreamConsumerWithContextArgsForCall)] + fake.describeStreamConsumerWithContextArgsForCall = append(fake.describeStreamConsumerWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamConsumerInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DescribeStreamConsumerWithContextStub + fakeReturns := fake.describeStreamConsumerWithContextReturns + fake.recordInvocation("DescribeStreamConsumerWithContext", []interface{}{arg1, arg2, arg3}) + fake.describeStreamConsumerWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerWithContextCallCount() int { + fake.describeStreamConsumerWithContextMutex.RLock() + defer fake.describeStreamConsumerWithContextMutex.RUnlock() + return len(fake.describeStreamConsumerWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerWithContextCalls(stub func(context.Context, *kinesis.DescribeStreamConsumerInput, ...request.Option) (*kinesis.DescribeStreamConsumerOutput, error)) { + fake.describeStreamConsumerWithContextMutex.Lock() + defer fake.describeStreamConsumerWithContextMutex.Unlock() + fake.DescribeStreamConsumerWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerWithContextArgsForCall(i int) (context.Context, *kinesis.DescribeStreamConsumerInput, []request.Option) { + fake.describeStreamConsumerWithContextMutex.RLock() + defer fake.describeStreamConsumerWithContextMutex.RUnlock() + argsForCall := fake.describeStreamConsumerWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerWithContextReturns(result1 *kinesis.DescribeStreamConsumerOutput, result2 error) { + fake.describeStreamConsumerWithContextMutex.Lock() + defer fake.describeStreamConsumerWithContextMutex.Unlock() + fake.DescribeStreamConsumerWithContextStub = nil + fake.describeStreamConsumerWithContextReturns = struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamConsumerWithContextReturnsOnCall(i int, result1 *kinesis.DescribeStreamConsumerOutput, result2 error) { + fake.describeStreamConsumerWithContextMutex.Lock() + defer fake.describeStreamConsumerWithContextMutex.Unlock() + fake.DescribeStreamConsumerWithContextStub = nil + if fake.describeStreamConsumerWithContextReturnsOnCall == nil { + fake.describeStreamConsumerWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + }) + } + fake.describeStreamConsumerWithContextReturnsOnCall[i] = struct { + result1 *kinesis.DescribeStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamPages(arg1 *kinesis.DescribeStreamInput, arg2 func(*kinesis.DescribeStreamOutput, bool) bool) error { + fake.describeStreamPagesMutex.Lock() + ret, specificReturn := fake.describeStreamPagesReturnsOnCall[len(fake.describeStreamPagesArgsForCall)] + fake.describeStreamPagesArgsForCall = append(fake.describeStreamPagesArgsForCall, struct { + arg1 *kinesis.DescribeStreamInput + arg2 func(*kinesis.DescribeStreamOutput, bool) bool + }{arg1, arg2}) + stub := fake.DescribeStreamPagesStub + fakeReturns := fake.describeStreamPagesReturns + fake.recordInvocation("DescribeStreamPages", []interface{}{arg1, arg2}) + fake.describeStreamPagesMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesCallCount() int { + fake.describeStreamPagesMutex.RLock() + defer fake.describeStreamPagesMutex.RUnlock() + return len(fake.describeStreamPagesArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesCalls(stub func(*kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool) error) { + fake.describeStreamPagesMutex.Lock() + defer fake.describeStreamPagesMutex.Unlock() + fake.DescribeStreamPagesStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesArgsForCall(i int) (*kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool) { + fake.describeStreamPagesMutex.RLock() + defer fake.describeStreamPagesMutex.RUnlock() + argsForCall := fake.describeStreamPagesArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesReturns(result1 error) { + fake.describeStreamPagesMutex.Lock() + defer fake.describeStreamPagesMutex.Unlock() + fake.DescribeStreamPagesStub = nil + fake.describeStreamPagesReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesReturnsOnCall(i int, result1 error) { + fake.describeStreamPagesMutex.Lock() + defer fake.describeStreamPagesMutex.Unlock() + fake.DescribeStreamPagesStub = nil + if fake.describeStreamPagesReturnsOnCall == nil { + fake.describeStreamPagesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.describeStreamPagesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesWithContext(arg1 context.Context, arg2 *kinesis.DescribeStreamInput, arg3 func(*kinesis.DescribeStreamOutput, bool) bool, arg4 ...request.Option) error { + fake.describeStreamPagesWithContextMutex.Lock() + ret, specificReturn := fake.describeStreamPagesWithContextReturnsOnCall[len(fake.describeStreamPagesWithContextArgsForCall)] + fake.describeStreamPagesWithContextArgsForCall = append(fake.describeStreamPagesWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 func(*kinesis.DescribeStreamOutput, bool) bool + arg4 []request.Option + }{arg1, arg2, arg3, arg4}) + stub := fake.DescribeStreamPagesWithContextStub + fakeReturns := fake.describeStreamPagesWithContextReturns + fake.recordInvocation("DescribeStreamPagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) + fake.describeStreamPagesWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesWithContextCallCount() int { + fake.describeStreamPagesWithContextMutex.RLock() + defer fake.describeStreamPagesWithContextMutex.RUnlock() + return len(fake.describeStreamPagesWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesWithContextCalls(stub func(context.Context, *kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool, ...request.Option) error) { + fake.describeStreamPagesWithContextMutex.Lock() + defer fake.describeStreamPagesWithContextMutex.Unlock() + fake.DescribeStreamPagesWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesWithContextArgsForCall(i int) (context.Context, *kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool, []request.Option) { + fake.describeStreamPagesWithContextMutex.RLock() + defer fake.describeStreamPagesWithContextMutex.RUnlock() + argsForCall := fake.describeStreamPagesWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesWithContextReturns(result1 error) { + fake.describeStreamPagesWithContextMutex.Lock() + defer fake.describeStreamPagesWithContextMutex.Unlock() + fake.DescribeStreamPagesWithContextStub = nil + fake.describeStreamPagesWithContextReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) DescribeStreamPagesWithContextReturnsOnCall(i int, result1 error) { + fake.describeStreamPagesWithContextMutex.Lock() + defer fake.describeStreamPagesWithContextMutex.Unlock() + fake.DescribeStreamPagesWithContextStub = nil + if fake.describeStreamPagesWithContextReturnsOnCall == nil { + fake.describeStreamPagesWithContextReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.describeStreamPagesWithContextReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) DescribeStreamRequest(arg1 *kinesis.DescribeStreamInput) (*request.Request, *kinesis.DescribeStreamOutput) { + fake.describeStreamRequestMutex.Lock() + ret, specificReturn := fake.describeStreamRequestReturnsOnCall[len(fake.describeStreamRequestArgsForCall)] + fake.describeStreamRequestArgsForCall = append(fake.describeStreamRequestArgsForCall, struct { + arg1 *kinesis.DescribeStreamInput + }{arg1}) + stub := fake.DescribeStreamRequestStub + fakeReturns := fake.describeStreamRequestReturns + fake.recordInvocation("DescribeStreamRequest", []interface{}{arg1}) + fake.describeStreamRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamRequestCallCount() int { + fake.describeStreamRequestMutex.RLock() + defer fake.describeStreamRequestMutex.RUnlock() + return len(fake.describeStreamRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamRequestCalls(stub func(*kinesis.DescribeStreamInput) (*request.Request, *kinesis.DescribeStreamOutput)) { + fake.describeStreamRequestMutex.Lock() + defer fake.describeStreamRequestMutex.Unlock() + fake.DescribeStreamRequestStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamRequestArgsForCall(i int) *kinesis.DescribeStreamInput { + fake.describeStreamRequestMutex.RLock() + defer fake.describeStreamRequestMutex.RUnlock() + argsForCall := fake.describeStreamRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeStreamRequestReturns(result1 *request.Request, result2 *kinesis.DescribeStreamOutput) { + fake.describeStreamRequestMutex.Lock() + defer fake.describeStreamRequestMutex.Unlock() + fake.DescribeStreamRequestStub = nil + fake.describeStreamRequestReturns = struct { + result1 *request.Request + result2 *kinesis.DescribeStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.DescribeStreamOutput) { + fake.describeStreamRequestMutex.Lock() + defer fake.describeStreamRequestMutex.Unlock() + fake.DescribeStreamRequestStub = nil + if fake.describeStreamRequestReturnsOnCall == nil { + fake.describeStreamRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeStreamOutput + }) + } + fake.describeStreamRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.DescribeStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamSummary(arg1 *kinesis.DescribeStreamSummaryInput) (*kinesis.DescribeStreamSummaryOutput, error) { + fake.describeStreamSummaryMutex.Lock() + ret, specificReturn := fake.describeStreamSummaryReturnsOnCall[len(fake.describeStreamSummaryArgsForCall)] + fake.describeStreamSummaryArgsForCall = append(fake.describeStreamSummaryArgsForCall, struct { + arg1 *kinesis.DescribeStreamSummaryInput + }{arg1}) + stub := fake.DescribeStreamSummaryStub + fakeReturns := fake.describeStreamSummaryReturns + fake.recordInvocation("DescribeStreamSummary", []interface{}{arg1}) + fake.describeStreamSummaryMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryCallCount() int { + fake.describeStreamSummaryMutex.RLock() + defer fake.describeStreamSummaryMutex.RUnlock() + return len(fake.describeStreamSummaryArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryCalls(stub func(*kinesis.DescribeStreamSummaryInput) (*kinesis.DescribeStreamSummaryOutput, error)) { + fake.describeStreamSummaryMutex.Lock() + defer fake.describeStreamSummaryMutex.Unlock() + fake.DescribeStreamSummaryStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryArgsForCall(i int) *kinesis.DescribeStreamSummaryInput { + fake.describeStreamSummaryMutex.RLock() + defer fake.describeStreamSummaryMutex.RUnlock() + argsForCall := fake.describeStreamSummaryArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryReturns(result1 *kinesis.DescribeStreamSummaryOutput, result2 error) { + fake.describeStreamSummaryMutex.Lock() + defer fake.describeStreamSummaryMutex.Unlock() + fake.DescribeStreamSummaryStub = nil + fake.describeStreamSummaryReturns = struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryReturnsOnCall(i int, result1 *kinesis.DescribeStreamSummaryOutput, result2 error) { + fake.describeStreamSummaryMutex.Lock() + defer fake.describeStreamSummaryMutex.Unlock() + fake.DescribeStreamSummaryStub = nil + if fake.describeStreamSummaryReturnsOnCall == nil { + fake.describeStreamSummaryReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + }) + } + fake.describeStreamSummaryReturnsOnCall[i] = struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryRequest(arg1 *kinesis.DescribeStreamSummaryInput) (*request.Request, *kinesis.DescribeStreamSummaryOutput) { + fake.describeStreamSummaryRequestMutex.Lock() + ret, specificReturn := fake.describeStreamSummaryRequestReturnsOnCall[len(fake.describeStreamSummaryRequestArgsForCall)] + fake.describeStreamSummaryRequestArgsForCall = append(fake.describeStreamSummaryRequestArgsForCall, struct { + arg1 *kinesis.DescribeStreamSummaryInput + }{arg1}) + stub := fake.DescribeStreamSummaryRequestStub + fakeReturns := fake.describeStreamSummaryRequestReturns + fake.recordInvocation("DescribeStreamSummaryRequest", []interface{}{arg1}) + fake.describeStreamSummaryRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryRequestCallCount() int { + fake.describeStreamSummaryRequestMutex.RLock() + defer fake.describeStreamSummaryRequestMutex.RUnlock() + return len(fake.describeStreamSummaryRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryRequestCalls(stub func(*kinesis.DescribeStreamSummaryInput) (*request.Request, *kinesis.DescribeStreamSummaryOutput)) { + fake.describeStreamSummaryRequestMutex.Lock() + defer fake.describeStreamSummaryRequestMutex.Unlock() + fake.DescribeStreamSummaryRequestStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryRequestArgsForCall(i int) *kinesis.DescribeStreamSummaryInput { + fake.describeStreamSummaryRequestMutex.RLock() + defer fake.describeStreamSummaryRequestMutex.RUnlock() + argsForCall := fake.describeStreamSummaryRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryRequestReturns(result1 *request.Request, result2 *kinesis.DescribeStreamSummaryOutput) { + fake.describeStreamSummaryRequestMutex.Lock() + defer fake.describeStreamSummaryRequestMutex.Unlock() + fake.DescribeStreamSummaryRequestStub = nil + fake.describeStreamSummaryRequestReturns = struct { + result1 *request.Request + result2 *kinesis.DescribeStreamSummaryOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.DescribeStreamSummaryOutput) { + fake.describeStreamSummaryRequestMutex.Lock() + defer fake.describeStreamSummaryRequestMutex.Unlock() + fake.DescribeStreamSummaryRequestStub = nil + if fake.describeStreamSummaryRequestReturnsOnCall == nil { + fake.describeStreamSummaryRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.DescribeStreamSummaryOutput + }) + } + fake.describeStreamSummaryRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.DescribeStreamSummaryOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryWithContext(arg1 context.Context, arg2 *kinesis.DescribeStreamSummaryInput, arg3 ...request.Option) (*kinesis.DescribeStreamSummaryOutput, error) { + fake.describeStreamSummaryWithContextMutex.Lock() + ret, specificReturn := fake.describeStreamSummaryWithContextReturnsOnCall[len(fake.describeStreamSummaryWithContextArgsForCall)] + fake.describeStreamSummaryWithContextArgsForCall = append(fake.describeStreamSummaryWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamSummaryInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DescribeStreamSummaryWithContextStub + fakeReturns := fake.describeStreamSummaryWithContextReturns + fake.recordInvocation("DescribeStreamSummaryWithContext", []interface{}{arg1, arg2, arg3}) + fake.describeStreamSummaryWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryWithContextCallCount() int { + fake.describeStreamSummaryWithContextMutex.RLock() + defer fake.describeStreamSummaryWithContextMutex.RUnlock() + return len(fake.describeStreamSummaryWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryWithContextCalls(stub func(context.Context, *kinesis.DescribeStreamSummaryInput, ...request.Option) (*kinesis.DescribeStreamSummaryOutput, error)) { + fake.describeStreamSummaryWithContextMutex.Lock() + defer fake.describeStreamSummaryWithContextMutex.Unlock() + fake.DescribeStreamSummaryWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryWithContextArgsForCall(i int) (context.Context, *kinesis.DescribeStreamSummaryInput, []request.Option) { + fake.describeStreamSummaryWithContextMutex.RLock() + defer fake.describeStreamSummaryWithContextMutex.RUnlock() + argsForCall := fake.describeStreamSummaryWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryWithContextReturns(result1 *kinesis.DescribeStreamSummaryOutput, result2 error) { + fake.describeStreamSummaryWithContextMutex.Lock() + defer fake.describeStreamSummaryWithContextMutex.Unlock() + fake.DescribeStreamSummaryWithContextStub = nil + fake.describeStreamSummaryWithContextReturns = struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamSummaryWithContextReturnsOnCall(i int, result1 *kinesis.DescribeStreamSummaryOutput, result2 error) { + fake.describeStreamSummaryWithContextMutex.Lock() + defer fake.describeStreamSummaryWithContextMutex.Unlock() + fake.DescribeStreamSummaryWithContextStub = nil + if fake.describeStreamSummaryWithContextReturnsOnCall == nil { + fake.describeStreamSummaryWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + }) + } + fake.describeStreamSummaryWithContextReturnsOnCall[i] = struct { + result1 *kinesis.DescribeStreamSummaryOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamWithContext(arg1 context.Context, arg2 *kinesis.DescribeStreamInput, arg3 ...request.Option) (*kinesis.DescribeStreamOutput, error) { + fake.describeStreamWithContextMutex.Lock() + ret, specificReturn := fake.describeStreamWithContextReturnsOnCall[len(fake.describeStreamWithContextArgsForCall)] + fake.describeStreamWithContextArgsForCall = append(fake.describeStreamWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DescribeStreamWithContextStub + fakeReturns := fake.describeStreamWithContextReturns + fake.recordInvocation("DescribeStreamWithContext", []interface{}{arg1, arg2, arg3}) + fake.describeStreamWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DescribeStreamWithContextCallCount() int { + fake.describeStreamWithContextMutex.RLock() + defer fake.describeStreamWithContextMutex.RUnlock() + return len(fake.describeStreamWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DescribeStreamWithContextCalls(stub func(context.Context, *kinesis.DescribeStreamInput, ...request.Option) (*kinesis.DescribeStreamOutput, error)) { + fake.describeStreamWithContextMutex.Lock() + defer fake.describeStreamWithContextMutex.Unlock() + fake.DescribeStreamWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DescribeStreamWithContextArgsForCall(i int) (context.Context, *kinesis.DescribeStreamInput, []request.Option) { + fake.describeStreamWithContextMutex.RLock() + defer fake.describeStreamWithContextMutex.RUnlock() + argsForCall := fake.describeStreamWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DescribeStreamWithContextReturns(result1 *kinesis.DescribeStreamOutput, result2 error) { + fake.describeStreamWithContextMutex.Lock() + defer fake.describeStreamWithContextMutex.Unlock() + fake.DescribeStreamWithContextStub = nil + fake.describeStreamWithContextReturns = struct { + result1 *kinesis.DescribeStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DescribeStreamWithContextReturnsOnCall(i int, result1 *kinesis.DescribeStreamOutput, result2 error) { + fake.describeStreamWithContextMutex.Lock() + defer fake.describeStreamWithContextMutex.Unlock() + fake.DescribeStreamWithContextStub = nil + if fake.describeStreamWithContextReturnsOnCall == nil { + fake.describeStreamWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.DescribeStreamOutput + result2 error + }) + } + fake.describeStreamWithContextReturnsOnCall[i] = struct { + result1 *kinesis.DescribeStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoring(arg1 *kinesis.DisableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) { + fake.disableEnhancedMonitoringMutex.Lock() + ret, specificReturn := fake.disableEnhancedMonitoringReturnsOnCall[len(fake.disableEnhancedMonitoringArgsForCall)] + fake.disableEnhancedMonitoringArgsForCall = append(fake.disableEnhancedMonitoringArgsForCall, struct { + arg1 *kinesis.DisableEnhancedMonitoringInput + }{arg1}) + stub := fake.DisableEnhancedMonitoringStub + fakeReturns := fake.disableEnhancedMonitoringReturns + fake.recordInvocation("DisableEnhancedMonitoring", []interface{}{arg1}) + fake.disableEnhancedMonitoringMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringCallCount() int { + fake.disableEnhancedMonitoringMutex.RLock() + defer fake.disableEnhancedMonitoringMutex.RUnlock() + return len(fake.disableEnhancedMonitoringArgsForCall) +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringCalls(stub func(*kinesis.DisableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error)) { + fake.disableEnhancedMonitoringMutex.Lock() + defer fake.disableEnhancedMonitoringMutex.Unlock() + fake.DisableEnhancedMonitoringStub = stub +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringArgsForCall(i int) *kinesis.DisableEnhancedMonitoringInput { + fake.disableEnhancedMonitoringMutex.RLock() + defer fake.disableEnhancedMonitoringMutex.RUnlock() + argsForCall := fake.disableEnhancedMonitoringArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringReturns(result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.disableEnhancedMonitoringMutex.Lock() + defer fake.disableEnhancedMonitoringMutex.Unlock() + fake.DisableEnhancedMonitoringStub = nil + fake.disableEnhancedMonitoringReturns = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringReturnsOnCall(i int, result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.disableEnhancedMonitoringMutex.Lock() + defer fake.disableEnhancedMonitoringMutex.Unlock() + fake.DisableEnhancedMonitoringStub = nil + if fake.disableEnhancedMonitoringReturnsOnCall == nil { + fake.disableEnhancedMonitoringReturnsOnCall = make(map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }) + } + fake.disableEnhancedMonitoringReturnsOnCall[i] = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringRequest(arg1 *kinesis.DisableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) { + fake.disableEnhancedMonitoringRequestMutex.Lock() + ret, specificReturn := fake.disableEnhancedMonitoringRequestReturnsOnCall[len(fake.disableEnhancedMonitoringRequestArgsForCall)] + fake.disableEnhancedMonitoringRequestArgsForCall = append(fake.disableEnhancedMonitoringRequestArgsForCall, struct { + arg1 *kinesis.DisableEnhancedMonitoringInput + }{arg1}) + stub := fake.DisableEnhancedMonitoringRequestStub + fakeReturns := fake.disableEnhancedMonitoringRequestReturns + fake.recordInvocation("DisableEnhancedMonitoringRequest", []interface{}{arg1}) + fake.disableEnhancedMonitoringRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringRequestCallCount() int { + fake.disableEnhancedMonitoringRequestMutex.RLock() + defer fake.disableEnhancedMonitoringRequestMutex.RUnlock() + return len(fake.disableEnhancedMonitoringRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringRequestCalls(stub func(*kinesis.DisableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput)) { + fake.disableEnhancedMonitoringRequestMutex.Lock() + defer fake.disableEnhancedMonitoringRequestMutex.Unlock() + fake.DisableEnhancedMonitoringRequestStub = stub +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringRequestArgsForCall(i int) *kinesis.DisableEnhancedMonitoringInput { + fake.disableEnhancedMonitoringRequestMutex.RLock() + defer fake.disableEnhancedMonitoringRequestMutex.RUnlock() + argsForCall := fake.disableEnhancedMonitoringRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringRequestReturns(result1 *request.Request, result2 *kinesis.EnhancedMonitoringOutput) { + fake.disableEnhancedMonitoringRequestMutex.Lock() + defer fake.disableEnhancedMonitoringRequestMutex.Unlock() + fake.DisableEnhancedMonitoringRequestStub = nil + fake.disableEnhancedMonitoringRequestReturns = struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.EnhancedMonitoringOutput) { + fake.disableEnhancedMonitoringRequestMutex.Lock() + defer fake.disableEnhancedMonitoringRequestMutex.Unlock() + fake.DisableEnhancedMonitoringRequestStub = nil + if fake.disableEnhancedMonitoringRequestReturnsOnCall == nil { + fake.disableEnhancedMonitoringRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + }) + } + fake.disableEnhancedMonitoringRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringWithContext(arg1 context.Context, arg2 *kinesis.DisableEnhancedMonitoringInput, arg3 ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) { + fake.disableEnhancedMonitoringWithContextMutex.Lock() + ret, specificReturn := fake.disableEnhancedMonitoringWithContextReturnsOnCall[len(fake.disableEnhancedMonitoringWithContextArgsForCall)] + fake.disableEnhancedMonitoringWithContextArgsForCall = append(fake.disableEnhancedMonitoringWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DisableEnhancedMonitoringInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.DisableEnhancedMonitoringWithContextStub + fakeReturns := fake.disableEnhancedMonitoringWithContextReturns + fake.recordInvocation("DisableEnhancedMonitoringWithContext", []interface{}{arg1, arg2, arg3}) + fake.disableEnhancedMonitoringWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringWithContextCallCount() int { + fake.disableEnhancedMonitoringWithContextMutex.RLock() + defer fake.disableEnhancedMonitoringWithContextMutex.RUnlock() + return len(fake.disableEnhancedMonitoringWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringWithContextCalls(stub func(context.Context, *kinesis.DisableEnhancedMonitoringInput, ...request.Option) (*kinesis.EnhancedMonitoringOutput, error)) { + fake.disableEnhancedMonitoringWithContextMutex.Lock() + defer fake.disableEnhancedMonitoringWithContextMutex.Unlock() + fake.DisableEnhancedMonitoringWithContextStub = stub +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringWithContextArgsForCall(i int) (context.Context, *kinesis.DisableEnhancedMonitoringInput, []request.Option) { + fake.disableEnhancedMonitoringWithContextMutex.RLock() + defer fake.disableEnhancedMonitoringWithContextMutex.RUnlock() + argsForCall := fake.disableEnhancedMonitoringWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringWithContextReturns(result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.disableEnhancedMonitoringWithContextMutex.Lock() + defer fake.disableEnhancedMonitoringWithContextMutex.Unlock() + fake.DisableEnhancedMonitoringWithContextStub = nil + fake.disableEnhancedMonitoringWithContextReturns = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) DisableEnhancedMonitoringWithContextReturnsOnCall(i int, result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.disableEnhancedMonitoringWithContextMutex.Lock() + defer fake.disableEnhancedMonitoringWithContextMutex.Unlock() + fake.DisableEnhancedMonitoringWithContextStub = nil + if fake.disableEnhancedMonitoringWithContextReturnsOnCall == nil { + fake.disableEnhancedMonitoringWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }) + } + fake.disableEnhancedMonitoringWithContextReturnsOnCall[i] = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoring(arg1 *kinesis.EnableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) { + fake.enableEnhancedMonitoringMutex.Lock() + ret, specificReturn := fake.enableEnhancedMonitoringReturnsOnCall[len(fake.enableEnhancedMonitoringArgsForCall)] + fake.enableEnhancedMonitoringArgsForCall = append(fake.enableEnhancedMonitoringArgsForCall, struct { + arg1 *kinesis.EnableEnhancedMonitoringInput + }{arg1}) + stub := fake.EnableEnhancedMonitoringStub + fakeReturns := fake.enableEnhancedMonitoringReturns + fake.recordInvocation("EnableEnhancedMonitoring", []interface{}{arg1}) + fake.enableEnhancedMonitoringMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringCallCount() int { + fake.enableEnhancedMonitoringMutex.RLock() + defer fake.enableEnhancedMonitoringMutex.RUnlock() + return len(fake.enableEnhancedMonitoringArgsForCall) +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringCalls(stub func(*kinesis.EnableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error)) { + fake.enableEnhancedMonitoringMutex.Lock() + defer fake.enableEnhancedMonitoringMutex.Unlock() + fake.EnableEnhancedMonitoringStub = stub +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringArgsForCall(i int) *kinesis.EnableEnhancedMonitoringInput { + fake.enableEnhancedMonitoringMutex.RLock() + defer fake.enableEnhancedMonitoringMutex.RUnlock() + argsForCall := fake.enableEnhancedMonitoringArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringReturns(result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.enableEnhancedMonitoringMutex.Lock() + defer fake.enableEnhancedMonitoringMutex.Unlock() + fake.EnableEnhancedMonitoringStub = nil + fake.enableEnhancedMonitoringReturns = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringReturnsOnCall(i int, result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.enableEnhancedMonitoringMutex.Lock() + defer fake.enableEnhancedMonitoringMutex.Unlock() + fake.EnableEnhancedMonitoringStub = nil + if fake.enableEnhancedMonitoringReturnsOnCall == nil { + fake.enableEnhancedMonitoringReturnsOnCall = make(map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }) + } + fake.enableEnhancedMonitoringReturnsOnCall[i] = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringRequest(arg1 *kinesis.EnableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) { + fake.enableEnhancedMonitoringRequestMutex.Lock() + ret, specificReturn := fake.enableEnhancedMonitoringRequestReturnsOnCall[len(fake.enableEnhancedMonitoringRequestArgsForCall)] + fake.enableEnhancedMonitoringRequestArgsForCall = append(fake.enableEnhancedMonitoringRequestArgsForCall, struct { + arg1 *kinesis.EnableEnhancedMonitoringInput + }{arg1}) + stub := fake.EnableEnhancedMonitoringRequestStub + fakeReturns := fake.enableEnhancedMonitoringRequestReturns + fake.recordInvocation("EnableEnhancedMonitoringRequest", []interface{}{arg1}) + fake.enableEnhancedMonitoringRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringRequestCallCount() int { + fake.enableEnhancedMonitoringRequestMutex.RLock() + defer fake.enableEnhancedMonitoringRequestMutex.RUnlock() + return len(fake.enableEnhancedMonitoringRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringRequestCalls(stub func(*kinesis.EnableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput)) { + fake.enableEnhancedMonitoringRequestMutex.Lock() + defer fake.enableEnhancedMonitoringRequestMutex.Unlock() + fake.EnableEnhancedMonitoringRequestStub = stub +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringRequestArgsForCall(i int) *kinesis.EnableEnhancedMonitoringInput { + fake.enableEnhancedMonitoringRequestMutex.RLock() + defer fake.enableEnhancedMonitoringRequestMutex.RUnlock() + argsForCall := fake.enableEnhancedMonitoringRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringRequestReturns(result1 *request.Request, result2 *kinesis.EnhancedMonitoringOutput) { + fake.enableEnhancedMonitoringRequestMutex.Lock() + defer fake.enableEnhancedMonitoringRequestMutex.Unlock() + fake.EnableEnhancedMonitoringRequestStub = nil + fake.enableEnhancedMonitoringRequestReturns = struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.EnhancedMonitoringOutput) { + fake.enableEnhancedMonitoringRequestMutex.Lock() + defer fake.enableEnhancedMonitoringRequestMutex.Unlock() + fake.EnableEnhancedMonitoringRequestStub = nil + if fake.enableEnhancedMonitoringRequestReturnsOnCall == nil { + fake.enableEnhancedMonitoringRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + }) + } + fake.enableEnhancedMonitoringRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.EnhancedMonitoringOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringWithContext(arg1 context.Context, arg2 *kinesis.EnableEnhancedMonitoringInput, arg3 ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) { + fake.enableEnhancedMonitoringWithContextMutex.Lock() + ret, specificReturn := fake.enableEnhancedMonitoringWithContextReturnsOnCall[len(fake.enableEnhancedMonitoringWithContextArgsForCall)] + fake.enableEnhancedMonitoringWithContextArgsForCall = append(fake.enableEnhancedMonitoringWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.EnableEnhancedMonitoringInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.EnableEnhancedMonitoringWithContextStub + fakeReturns := fake.enableEnhancedMonitoringWithContextReturns + fake.recordInvocation("EnableEnhancedMonitoringWithContext", []interface{}{arg1, arg2, arg3}) + fake.enableEnhancedMonitoringWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringWithContextCallCount() int { + fake.enableEnhancedMonitoringWithContextMutex.RLock() + defer fake.enableEnhancedMonitoringWithContextMutex.RUnlock() + return len(fake.enableEnhancedMonitoringWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringWithContextCalls(stub func(context.Context, *kinesis.EnableEnhancedMonitoringInput, ...request.Option) (*kinesis.EnhancedMonitoringOutput, error)) { + fake.enableEnhancedMonitoringWithContextMutex.Lock() + defer fake.enableEnhancedMonitoringWithContextMutex.Unlock() + fake.EnableEnhancedMonitoringWithContextStub = stub +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringWithContextArgsForCall(i int) (context.Context, *kinesis.EnableEnhancedMonitoringInput, []request.Option) { + fake.enableEnhancedMonitoringWithContextMutex.RLock() + defer fake.enableEnhancedMonitoringWithContextMutex.RUnlock() + argsForCall := fake.enableEnhancedMonitoringWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringWithContextReturns(result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.enableEnhancedMonitoringWithContextMutex.Lock() + defer fake.enableEnhancedMonitoringWithContextMutex.Unlock() + fake.EnableEnhancedMonitoringWithContextStub = nil + fake.enableEnhancedMonitoringWithContextReturns = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) EnableEnhancedMonitoringWithContextReturnsOnCall(i int, result1 *kinesis.EnhancedMonitoringOutput, result2 error) { + fake.enableEnhancedMonitoringWithContextMutex.Lock() + defer fake.enableEnhancedMonitoringWithContextMutex.Unlock() + fake.EnableEnhancedMonitoringWithContextStub = nil + if fake.enableEnhancedMonitoringWithContextReturnsOnCall == nil { + fake.enableEnhancedMonitoringWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }) + } + fake.enableEnhancedMonitoringWithContextReturnsOnCall[i] = struct { + result1 *kinesis.EnhancedMonitoringOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetRecords(arg1 *kinesis.GetRecordsInput) (*kinesis.GetRecordsOutput, error) { + fake.getRecordsMutex.Lock() + ret, specificReturn := fake.getRecordsReturnsOnCall[len(fake.getRecordsArgsForCall)] + fake.getRecordsArgsForCall = append(fake.getRecordsArgsForCall, struct { + arg1 *kinesis.GetRecordsInput + }{arg1}) + stub := fake.GetRecordsStub + fakeReturns := fake.getRecordsReturns + fake.recordInvocation("GetRecords", []interface{}{arg1}) + fake.getRecordsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) GetRecordsCallCount() int { + fake.getRecordsMutex.RLock() + defer fake.getRecordsMutex.RUnlock() + return len(fake.getRecordsArgsForCall) +} + +func (fake *FakeKinesisAPI) GetRecordsCalls(stub func(*kinesis.GetRecordsInput) (*kinesis.GetRecordsOutput, error)) { + fake.getRecordsMutex.Lock() + defer fake.getRecordsMutex.Unlock() + fake.GetRecordsStub = stub +} + +func (fake *FakeKinesisAPI) GetRecordsArgsForCall(i int) *kinesis.GetRecordsInput { + fake.getRecordsMutex.RLock() + defer fake.getRecordsMutex.RUnlock() + argsForCall := fake.getRecordsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) GetRecordsReturns(result1 *kinesis.GetRecordsOutput, result2 error) { + fake.getRecordsMutex.Lock() + defer fake.getRecordsMutex.Unlock() + fake.GetRecordsStub = nil + fake.getRecordsReturns = struct { + result1 *kinesis.GetRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetRecordsReturnsOnCall(i int, result1 *kinesis.GetRecordsOutput, result2 error) { + fake.getRecordsMutex.Lock() + defer fake.getRecordsMutex.Unlock() + fake.GetRecordsStub = nil + if fake.getRecordsReturnsOnCall == nil { + fake.getRecordsReturnsOnCall = make(map[int]struct { + result1 *kinesis.GetRecordsOutput + result2 error + }) + } + fake.getRecordsReturnsOnCall[i] = struct { + result1 *kinesis.GetRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetRecordsRequest(arg1 *kinesis.GetRecordsInput) (*request.Request, *kinesis.GetRecordsOutput) { + fake.getRecordsRequestMutex.Lock() + ret, specificReturn := fake.getRecordsRequestReturnsOnCall[len(fake.getRecordsRequestArgsForCall)] + fake.getRecordsRequestArgsForCall = append(fake.getRecordsRequestArgsForCall, struct { + arg1 *kinesis.GetRecordsInput + }{arg1}) + stub := fake.GetRecordsRequestStub + fakeReturns := fake.getRecordsRequestReturns + fake.recordInvocation("GetRecordsRequest", []interface{}{arg1}) + fake.getRecordsRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) GetRecordsRequestCallCount() int { + fake.getRecordsRequestMutex.RLock() + defer fake.getRecordsRequestMutex.RUnlock() + return len(fake.getRecordsRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) GetRecordsRequestCalls(stub func(*kinesis.GetRecordsInput) (*request.Request, *kinesis.GetRecordsOutput)) { + fake.getRecordsRequestMutex.Lock() + defer fake.getRecordsRequestMutex.Unlock() + fake.GetRecordsRequestStub = stub +} + +func (fake *FakeKinesisAPI) GetRecordsRequestArgsForCall(i int) *kinesis.GetRecordsInput { + fake.getRecordsRequestMutex.RLock() + defer fake.getRecordsRequestMutex.RUnlock() + argsForCall := fake.getRecordsRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) GetRecordsRequestReturns(result1 *request.Request, result2 *kinesis.GetRecordsOutput) { + fake.getRecordsRequestMutex.Lock() + defer fake.getRecordsRequestMutex.Unlock() + fake.GetRecordsRequestStub = nil + fake.getRecordsRequestReturns = struct { + result1 *request.Request + result2 *kinesis.GetRecordsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetRecordsRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.GetRecordsOutput) { + fake.getRecordsRequestMutex.Lock() + defer fake.getRecordsRequestMutex.Unlock() + fake.GetRecordsRequestStub = nil + if fake.getRecordsRequestReturnsOnCall == nil { + fake.getRecordsRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.GetRecordsOutput + }) + } + fake.getRecordsRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.GetRecordsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetRecordsWithContext(arg1 context.Context, arg2 *kinesis.GetRecordsInput, arg3 ...request.Option) (*kinesis.GetRecordsOutput, error) { + fake.getRecordsWithContextMutex.Lock() + ret, specificReturn := fake.getRecordsWithContextReturnsOnCall[len(fake.getRecordsWithContextArgsForCall)] + fake.getRecordsWithContextArgsForCall = append(fake.getRecordsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.GetRecordsInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.GetRecordsWithContextStub + fakeReturns := fake.getRecordsWithContextReturns + fake.recordInvocation("GetRecordsWithContext", []interface{}{arg1, arg2, arg3}) + fake.getRecordsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) GetRecordsWithContextCallCount() int { + fake.getRecordsWithContextMutex.RLock() + defer fake.getRecordsWithContextMutex.RUnlock() + return len(fake.getRecordsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) GetRecordsWithContextCalls(stub func(context.Context, *kinesis.GetRecordsInput, ...request.Option) (*kinesis.GetRecordsOutput, error)) { + fake.getRecordsWithContextMutex.Lock() + defer fake.getRecordsWithContextMutex.Unlock() + fake.GetRecordsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) GetRecordsWithContextArgsForCall(i int) (context.Context, *kinesis.GetRecordsInput, []request.Option) { + fake.getRecordsWithContextMutex.RLock() + defer fake.getRecordsWithContextMutex.RUnlock() + argsForCall := fake.getRecordsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) GetRecordsWithContextReturns(result1 *kinesis.GetRecordsOutput, result2 error) { + fake.getRecordsWithContextMutex.Lock() + defer fake.getRecordsWithContextMutex.Unlock() + fake.GetRecordsWithContextStub = nil + fake.getRecordsWithContextReturns = struct { + result1 *kinesis.GetRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetRecordsWithContextReturnsOnCall(i int, result1 *kinesis.GetRecordsOutput, result2 error) { + fake.getRecordsWithContextMutex.Lock() + defer fake.getRecordsWithContextMutex.Unlock() + fake.GetRecordsWithContextStub = nil + if fake.getRecordsWithContextReturnsOnCall == nil { + fake.getRecordsWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.GetRecordsOutput + result2 error + }) + } + fake.getRecordsWithContextReturnsOnCall[i] = struct { + result1 *kinesis.GetRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetShardIterator(arg1 *kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error) { + fake.getShardIteratorMutex.Lock() + ret, specificReturn := fake.getShardIteratorReturnsOnCall[len(fake.getShardIteratorArgsForCall)] + fake.getShardIteratorArgsForCall = append(fake.getShardIteratorArgsForCall, struct { + arg1 *kinesis.GetShardIteratorInput + }{arg1}) + stub := fake.GetShardIteratorStub + fakeReturns := fake.getShardIteratorReturns + fake.recordInvocation("GetShardIterator", []interface{}{arg1}) + fake.getShardIteratorMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) GetShardIteratorCallCount() int { + fake.getShardIteratorMutex.RLock() + defer fake.getShardIteratorMutex.RUnlock() + return len(fake.getShardIteratorArgsForCall) +} + +func (fake *FakeKinesisAPI) GetShardIteratorCalls(stub func(*kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error)) { + fake.getShardIteratorMutex.Lock() + defer fake.getShardIteratorMutex.Unlock() + fake.GetShardIteratorStub = stub +} + +func (fake *FakeKinesisAPI) GetShardIteratorArgsForCall(i int) *kinesis.GetShardIteratorInput { + fake.getShardIteratorMutex.RLock() + defer fake.getShardIteratorMutex.RUnlock() + argsForCall := fake.getShardIteratorArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) GetShardIteratorReturns(result1 *kinesis.GetShardIteratorOutput, result2 error) { + fake.getShardIteratorMutex.Lock() + defer fake.getShardIteratorMutex.Unlock() + fake.GetShardIteratorStub = nil + fake.getShardIteratorReturns = struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetShardIteratorReturnsOnCall(i int, result1 *kinesis.GetShardIteratorOutput, result2 error) { + fake.getShardIteratorMutex.Lock() + defer fake.getShardIteratorMutex.Unlock() + fake.GetShardIteratorStub = nil + if fake.getShardIteratorReturnsOnCall == nil { + fake.getShardIteratorReturnsOnCall = make(map[int]struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + }) + } + fake.getShardIteratorReturnsOnCall[i] = struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetShardIteratorRequest(arg1 *kinesis.GetShardIteratorInput) (*request.Request, *kinesis.GetShardIteratorOutput) { + fake.getShardIteratorRequestMutex.Lock() + ret, specificReturn := fake.getShardIteratorRequestReturnsOnCall[len(fake.getShardIteratorRequestArgsForCall)] + fake.getShardIteratorRequestArgsForCall = append(fake.getShardIteratorRequestArgsForCall, struct { + arg1 *kinesis.GetShardIteratorInput + }{arg1}) + stub := fake.GetShardIteratorRequestStub + fakeReturns := fake.getShardIteratorRequestReturns + fake.recordInvocation("GetShardIteratorRequest", []interface{}{arg1}) + fake.getShardIteratorRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) GetShardIteratorRequestCallCount() int { + fake.getShardIteratorRequestMutex.RLock() + defer fake.getShardIteratorRequestMutex.RUnlock() + return len(fake.getShardIteratorRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) GetShardIteratorRequestCalls(stub func(*kinesis.GetShardIteratorInput) (*request.Request, *kinesis.GetShardIteratorOutput)) { + fake.getShardIteratorRequestMutex.Lock() + defer fake.getShardIteratorRequestMutex.Unlock() + fake.GetShardIteratorRequestStub = stub +} + +func (fake *FakeKinesisAPI) GetShardIteratorRequestArgsForCall(i int) *kinesis.GetShardIteratorInput { + fake.getShardIteratorRequestMutex.RLock() + defer fake.getShardIteratorRequestMutex.RUnlock() + argsForCall := fake.getShardIteratorRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) GetShardIteratorRequestReturns(result1 *request.Request, result2 *kinesis.GetShardIteratorOutput) { + fake.getShardIteratorRequestMutex.Lock() + defer fake.getShardIteratorRequestMutex.Unlock() + fake.GetShardIteratorRequestStub = nil + fake.getShardIteratorRequestReturns = struct { + result1 *request.Request + result2 *kinesis.GetShardIteratorOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetShardIteratorRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.GetShardIteratorOutput) { + fake.getShardIteratorRequestMutex.Lock() + defer fake.getShardIteratorRequestMutex.Unlock() + fake.GetShardIteratorRequestStub = nil + if fake.getShardIteratorRequestReturnsOnCall == nil { + fake.getShardIteratorRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.GetShardIteratorOutput + }) + } + fake.getShardIteratorRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.GetShardIteratorOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetShardIteratorWithContext(arg1 context.Context, arg2 *kinesis.GetShardIteratorInput, arg3 ...request.Option) (*kinesis.GetShardIteratorOutput, error) { + fake.getShardIteratorWithContextMutex.Lock() + ret, specificReturn := fake.getShardIteratorWithContextReturnsOnCall[len(fake.getShardIteratorWithContextArgsForCall)] + fake.getShardIteratorWithContextArgsForCall = append(fake.getShardIteratorWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.GetShardIteratorInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.GetShardIteratorWithContextStub + fakeReturns := fake.getShardIteratorWithContextReturns + fake.recordInvocation("GetShardIteratorWithContext", []interface{}{arg1, arg2, arg3}) + fake.getShardIteratorWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) GetShardIteratorWithContextCallCount() int { + fake.getShardIteratorWithContextMutex.RLock() + defer fake.getShardIteratorWithContextMutex.RUnlock() + return len(fake.getShardIteratorWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) GetShardIteratorWithContextCalls(stub func(context.Context, *kinesis.GetShardIteratorInput, ...request.Option) (*kinesis.GetShardIteratorOutput, error)) { + fake.getShardIteratorWithContextMutex.Lock() + defer fake.getShardIteratorWithContextMutex.Unlock() + fake.GetShardIteratorWithContextStub = stub +} + +func (fake *FakeKinesisAPI) GetShardIteratorWithContextArgsForCall(i int) (context.Context, *kinesis.GetShardIteratorInput, []request.Option) { + fake.getShardIteratorWithContextMutex.RLock() + defer fake.getShardIteratorWithContextMutex.RUnlock() + argsForCall := fake.getShardIteratorWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) GetShardIteratorWithContextReturns(result1 *kinesis.GetShardIteratorOutput, result2 error) { + fake.getShardIteratorWithContextMutex.Lock() + defer fake.getShardIteratorWithContextMutex.Unlock() + fake.GetShardIteratorWithContextStub = nil + fake.getShardIteratorWithContextReturns = struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) GetShardIteratorWithContextReturnsOnCall(i int, result1 *kinesis.GetShardIteratorOutput, result2 error) { + fake.getShardIteratorWithContextMutex.Lock() + defer fake.getShardIteratorWithContextMutex.Unlock() + fake.GetShardIteratorWithContextStub = nil + if fake.getShardIteratorWithContextReturnsOnCall == nil { + fake.getShardIteratorWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + }) + } + fake.getShardIteratorWithContextReturnsOnCall[i] = struct { + result1 *kinesis.GetShardIteratorOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriod(arg1 *kinesis.IncreaseStreamRetentionPeriodInput) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) { + fake.increaseStreamRetentionPeriodMutex.Lock() + ret, specificReturn := fake.increaseStreamRetentionPeriodReturnsOnCall[len(fake.increaseStreamRetentionPeriodArgsForCall)] + fake.increaseStreamRetentionPeriodArgsForCall = append(fake.increaseStreamRetentionPeriodArgsForCall, struct { + arg1 *kinesis.IncreaseStreamRetentionPeriodInput + }{arg1}) + stub := fake.IncreaseStreamRetentionPeriodStub + fakeReturns := fake.increaseStreamRetentionPeriodReturns + fake.recordInvocation("IncreaseStreamRetentionPeriod", []interface{}{arg1}) + fake.increaseStreamRetentionPeriodMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodCallCount() int { + fake.increaseStreamRetentionPeriodMutex.RLock() + defer fake.increaseStreamRetentionPeriodMutex.RUnlock() + return len(fake.increaseStreamRetentionPeriodArgsForCall) +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodCalls(stub func(*kinesis.IncreaseStreamRetentionPeriodInput) (*kinesis.IncreaseStreamRetentionPeriodOutput, error)) { + fake.increaseStreamRetentionPeriodMutex.Lock() + defer fake.increaseStreamRetentionPeriodMutex.Unlock() + fake.IncreaseStreamRetentionPeriodStub = stub +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodArgsForCall(i int) *kinesis.IncreaseStreamRetentionPeriodInput { + fake.increaseStreamRetentionPeriodMutex.RLock() + defer fake.increaseStreamRetentionPeriodMutex.RUnlock() + argsForCall := fake.increaseStreamRetentionPeriodArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodReturns(result1 *kinesis.IncreaseStreamRetentionPeriodOutput, result2 error) { + fake.increaseStreamRetentionPeriodMutex.Lock() + defer fake.increaseStreamRetentionPeriodMutex.Unlock() + fake.IncreaseStreamRetentionPeriodStub = nil + fake.increaseStreamRetentionPeriodReturns = struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodReturnsOnCall(i int, result1 *kinesis.IncreaseStreamRetentionPeriodOutput, result2 error) { + fake.increaseStreamRetentionPeriodMutex.Lock() + defer fake.increaseStreamRetentionPeriodMutex.Unlock() + fake.IncreaseStreamRetentionPeriodStub = nil + if fake.increaseStreamRetentionPeriodReturnsOnCall == nil { + fake.increaseStreamRetentionPeriodReturnsOnCall = make(map[int]struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + }) + } + fake.increaseStreamRetentionPeriodReturnsOnCall[i] = struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodRequest(arg1 *kinesis.IncreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.IncreaseStreamRetentionPeriodOutput) { + fake.increaseStreamRetentionPeriodRequestMutex.Lock() + ret, specificReturn := fake.increaseStreamRetentionPeriodRequestReturnsOnCall[len(fake.increaseStreamRetentionPeriodRequestArgsForCall)] + fake.increaseStreamRetentionPeriodRequestArgsForCall = append(fake.increaseStreamRetentionPeriodRequestArgsForCall, struct { + arg1 *kinesis.IncreaseStreamRetentionPeriodInput + }{arg1}) + stub := fake.IncreaseStreamRetentionPeriodRequestStub + fakeReturns := fake.increaseStreamRetentionPeriodRequestReturns + fake.recordInvocation("IncreaseStreamRetentionPeriodRequest", []interface{}{arg1}) + fake.increaseStreamRetentionPeriodRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodRequestCallCount() int { + fake.increaseStreamRetentionPeriodRequestMutex.RLock() + defer fake.increaseStreamRetentionPeriodRequestMutex.RUnlock() + return len(fake.increaseStreamRetentionPeriodRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodRequestCalls(stub func(*kinesis.IncreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.IncreaseStreamRetentionPeriodOutput)) { + fake.increaseStreamRetentionPeriodRequestMutex.Lock() + defer fake.increaseStreamRetentionPeriodRequestMutex.Unlock() + fake.IncreaseStreamRetentionPeriodRequestStub = stub +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodRequestArgsForCall(i int) *kinesis.IncreaseStreamRetentionPeriodInput { + fake.increaseStreamRetentionPeriodRequestMutex.RLock() + defer fake.increaseStreamRetentionPeriodRequestMutex.RUnlock() + argsForCall := fake.increaseStreamRetentionPeriodRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodRequestReturns(result1 *request.Request, result2 *kinesis.IncreaseStreamRetentionPeriodOutput) { + fake.increaseStreamRetentionPeriodRequestMutex.Lock() + defer fake.increaseStreamRetentionPeriodRequestMutex.Unlock() + fake.IncreaseStreamRetentionPeriodRequestStub = nil + fake.increaseStreamRetentionPeriodRequestReturns = struct { + result1 *request.Request + result2 *kinesis.IncreaseStreamRetentionPeriodOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.IncreaseStreamRetentionPeriodOutput) { + fake.increaseStreamRetentionPeriodRequestMutex.Lock() + defer fake.increaseStreamRetentionPeriodRequestMutex.Unlock() + fake.IncreaseStreamRetentionPeriodRequestStub = nil + if fake.increaseStreamRetentionPeriodRequestReturnsOnCall == nil { + fake.increaseStreamRetentionPeriodRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.IncreaseStreamRetentionPeriodOutput + }) + } + fake.increaseStreamRetentionPeriodRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.IncreaseStreamRetentionPeriodOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodWithContext(arg1 context.Context, arg2 *kinesis.IncreaseStreamRetentionPeriodInput, arg3 ...request.Option) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) { + fake.increaseStreamRetentionPeriodWithContextMutex.Lock() + ret, specificReturn := fake.increaseStreamRetentionPeriodWithContextReturnsOnCall[len(fake.increaseStreamRetentionPeriodWithContextArgsForCall)] + fake.increaseStreamRetentionPeriodWithContextArgsForCall = append(fake.increaseStreamRetentionPeriodWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.IncreaseStreamRetentionPeriodInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.IncreaseStreamRetentionPeriodWithContextStub + fakeReturns := fake.increaseStreamRetentionPeriodWithContextReturns + fake.recordInvocation("IncreaseStreamRetentionPeriodWithContext", []interface{}{arg1, arg2, arg3}) + fake.increaseStreamRetentionPeriodWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodWithContextCallCount() int { + fake.increaseStreamRetentionPeriodWithContextMutex.RLock() + defer fake.increaseStreamRetentionPeriodWithContextMutex.RUnlock() + return len(fake.increaseStreamRetentionPeriodWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodWithContextCalls(stub func(context.Context, *kinesis.IncreaseStreamRetentionPeriodInput, ...request.Option) (*kinesis.IncreaseStreamRetentionPeriodOutput, error)) { + fake.increaseStreamRetentionPeriodWithContextMutex.Lock() + defer fake.increaseStreamRetentionPeriodWithContextMutex.Unlock() + fake.IncreaseStreamRetentionPeriodWithContextStub = stub +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodWithContextArgsForCall(i int) (context.Context, *kinesis.IncreaseStreamRetentionPeriodInput, []request.Option) { + fake.increaseStreamRetentionPeriodWithContextMutex.RLock() + defer fake.increaseStreamRetentionPeriodWithContextMutex.RUnlock() + argsForCall := fake.increaseStreamRetentionPeriodWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodWithContextReturns(result1 *kinesis.IncreaseStreamRetentionPeriodOutput, result2 error) { + fake.increaseStreamRetentionPeriodWithContextMutex.Lock() + defer fake.increaseStreamRetentionPeriodWithContextMutex.Unlock() + fake.IncreaseStreamRetentionPeriodWithContextStub = nil + fake.increaseStreamRetentionPeriodWithContextReturns = struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) IncreaseStreamRetentionPeriodWithContextReturnsOnCall(i int, result1 *kinesis.IncreaseStreamRetentionPeriodOutput, result2 error) { + fake.increaseStreamRetentionPeriodWithContextMutex.Lock() + defer fake.increaseStreamRetentionPeriodWithContextMutex.Unlock() + fake.IncreaseStreamRetentionPeriodWithContextStub = nil + if fake.increaseStreamRetentionPeriodWithContextReturnsOnCall == nil { + fake.increaseStreamRetentionPeriodWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + }) + } + fake.increaseStreamRetentionPeriodWithContextReturnsOnCall[i] = struct { + result1 *kinesis.IncreaseStreamRetentionPeriodOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListShards(arg1 *kinesis.ListShardsInput) (*kinesis.ListShardsOutput, error) { + fake.listShardsMutex.Lock() + ret, specificReturn := fake.listShardsReturnsOnCall[len(fake.listShardsArgsForCall)] + fake.listShardsArgsForCall = append(fake.listShardsArgsForCall, struct { + arg1 *kinesis.ListShardsInput + }{arg1}) + stub := fake.ListShardsStub + fakeReturns := fake.listShardsReturns + fake.recordInvocation("ListShards", []interface{}{arg1}) + fake.listShardsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListShardsCallCount() int { + fake.listShardsMutex.RLock() + defer fake.listShardsMutex.RUnlock() + return len(fake.listShardsArgsForCall) +} + +func (fake *FakeKinesisAPI) ListShardsCalls(stub func(*kinesis.ListShardsInput) (*kinesis.ListShardsOutput, error)) { + fake.listShardsMutex.Lock() + defer fake.listShardsMutex.Unlock() + fake.ListShardsStub = stub +} + +func (fake *FakeKinesisAPI) ListShardsArgsForCall(i int) *kinesis.ListShardsInput { + fake.listShardsMutex.RLock() + defer fake.listShardsMutex.RUnlock() + argsForCall := fake.listShardsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListShardsReturns(result1 *kinesis.ListShardsOutput, result2 error) { + fake.listShardsMutex.Lock() + defer fake.listShardsMutex.Unlock() + fake.ListShardsStub = nil + fake.listShardsReturns = struct { + result1 *kinesis.ListShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListShardsReturnsOnCall(i int, result1 *kinesis.ListShardsOutput, result2 error) { + fake.listShardsMutex.Lock() + defer fake.listShardsMutex.Unlock() + fake.ListShardsStub = nil + if fake.listShardsReturnsOnCall == nil { + fake.listShardsReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListShardsOutput + result2 error + }) + } + fake.listShardsReturnsOnCall[i] = struct { + result1 *kinesis.ListShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListShardsRequest(arg1 *kinesis.ListShardsInput) (*request.Request, *kinesis.ListShardsOutput) { + fake.listShardsRequestMutex.Lock() + ret, specificReturn := fake.listShardsRequestReturnsOnCall[len(fake.listShardsRequestArgsForCall)] + fake.listShardsRequestArgsForCall = append(fake.listShardsRequestArgsForCall, struct { + arg1 *kinesis.ListShardsInput + }{arg1}) + stub := fake.ListShardsRequestStub + fakeReturns := fake.listShardsRequestReturns + fake.recordInvocation("ListShardsRequest", []interface{}{arg1}) + fake.listShardsRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListShardsRequestCallCount() int { + fake.listShardsRequestMutex.RLock() + defer fake.listShardsRequestMutex.RUnlock() + return len(fake.listShardsRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) ListShardsRequestCalls(stub func(*kinesis.ListShardsInput) (*request.Request, *kinesis.ListShardsOutput)) { + fake.listShardsRequestMutex.Lock() + defer fake.listShardsRequestMutex.Unlock() + fake.ListShardsRequestStub = stub +} + +func (fake *FakeKinesisAPI) ListShardsRequestArgsForCall(i int) *kinesis.ListShardsInput { + fake.listShardsRequestMutex.RLock() + defer fake.listShardsRequestMutex.RUnlock() + argsForCall := fake.listShardsRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListShardsRequestReturns(result1 *request.Request, result2 *kinesis.ListShardsOutput) { + fake.listShardsRequestMutex.Lock() + defer fake.listShardsRequestMutex.Unlock() + fake.ListShardsRequestStub = nil + fake.listShardsRequestReturns = struct { + result1 *request.Request + result2 *kinesis.ListShardsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListShardsRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.ListShardsOutput) { + fake.listShardsRequestMutex.Lock() + defer fake.listShardsRequestMutex.Unlock() + fake.ListShardsRequestStub = nil + if fake.listShardsRequestReturnsOnCall == nil { + fake.listShardsRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.ListShardsOutput + }) + } + fake.listShardsRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.ListShardsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListShardsWithContext(arg1 context.Context, arg2 *kinesis.ListShardsInput, arg3 ...request.Option) (*kinesis.ListShardsOutput, error) { + fake.listShardsWithContextMutex.Lock() + ret, specificReturn := fake.listShardsWithContextReturnsOnCall[len(fake.listShardsWithContextArgsForCall)] + fake.listShardsWithContextArgsForCall = append(fake.listShardsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.ListShardsInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.ListShardsWithContextStub + fakeReturns := fake.listShardsWithContextReturns + fake.recordInvocation("ListShardsWithContext", []interface{}{arg1, arg2, arg3}) + fake.listShardsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListShardsWithContextCallCount() int { + fake.listShardsWithContextMutex.RLock() + defer fake.listShardsWithContextMutex.RUnlock() + return len(fake.listShardsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) ListShardsWithContextCalls(stub func(context.Context, *kinesis.ListShardsInput, ...request.Option) (*kinesis.ListShardsOutput, error)) { + fake.listShardsWithContextMutex.Lock() + defer fake.listShardsWithContextMutex.Unlock() + fake.ListShardsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) ListShardsWithContextArgsForCall(i int) (context.Context, *kinesis.ListShardsInput, []request.Option) { + fake.listShardsWithContextMutex.RLock() + defer fake.listShardsWithContextMutex.RUnlock() + argsForCall := fake.listShardsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) ListShardsWithContextReturns(result1 *kinesis.ListShardsOutput, result2 error) { + fake.listShardsWithContextMutex.Lock() + defer fake.listShardsWithContextMutex.Unlock() + fake.ListShardsWithContextStub = nil + fake.listShardsWithContextReturns = struct { + result1 *kinesis.ListShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListShardsWithContextReturnsOnCall(i int, result1 *kinesis.ListShardsOutput, result2 error) { + fake.listShardsWithContextMutex.Lock() + defer fake.listShardsWithContextMutex.Unlock() + fake.ListShardsWithContextStub = nil + if fake.listShardsWithContextReturnsOnCall == nil { + fake.listShardsWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListShardsOutput + result2 error + }) + } + fake.listShardsWithContextReturnsOnCall[i] = struct { + result1 *kinesis.ListShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamConsumers(arg1 *kinesis.ListStreamConsumersInput) (*kinesis.ListStreamConsumersOutput, error) { + fake.listStreamConsumersMutex.Lock() + ret, specificReturn := fake.listStreamConsumersReturnsOnCall[len(fake.listStreamConsumersArgsForCall)] + fake.listStreamConsumersArgsForCall = append(fake.listStreamConsumersArgsForCall, struct { + arg1 *kinesis.ListStreamConsumersInput + }{arg1}) + stub := fake.ListStreamConsumersStub + fakeReturns := fake.listStreamConsumersReturns + fake.recordInvocation("ListStreamConsumers", []interface{}{arg1}) + fake.listStreamConsumersMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersCallCount() int { + fake.listStreamConsumersMutex.RLock() + defer fake.listStreamConsumersMutex.RUnlock() + return len(fake.listStreamConsumersArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamConsumersCalls(stub func(*kinesis.ListStreamConsumersInput) (*kinesis.ListStreamConsumersOutput, error)) { + fake.listStreamConsumersMutex.Lock() + defer fake.listStreamConsumersMutex.Unlock() + fake.ListStreamConsumersStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamConsumersArgsForCall(i int) *kinesis.ListStreamConsumersInput { + fake.listStreamConsumersMutex.RLock() + defer fake.listStreamConsumersMutex.RUnlock() + argsForCall := fake.listStreamConsumersArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersReturns(result1 *kinesis.ListStreamConsumersOutput, result2 error) { + fake.listStreamConsumersMutex.Lock() + defer fake.listStreamConsumersMutex.Unlock() + fake.ListStreamConsumersStub = nil + fake.listStreamConsumersReturns = struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersReturnsOnCall(i int, result1 *kinesis.ListStreamConsumersOutput, result2 error) { + fake.listStreamConsumersMutex.Lock() + defer fake.listStreamConsumersMutex.Unlock() + fake.ListStreamConsumersStub = nil + if fake.listStreamConsumersReturnsOnCall == nil { + fake.listStreamConsumersReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + }) + } + fake.listStreamConsumersReturnsOnCall[i] = struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPages(arg1 *kinesis.ListStreamConsumersInput, arg2 func(*kinesis.ListStreamConsumersOutput, bool) bool) error { + fake.listStreamConsumersPagesMutex.Lock() + ret, specificReturn := fake.listStreamConsumersPagesReturnsOnCall[len(fake.listStreamConsumersPagesArgsForCall)] + fake.listStreamConsumersPagesArgsForCall = append(fake.listStreamConsumersPagesArgsForCall, struct { + arg1 *kinesis.ListStreamConsumersInput + arg2 func(*kinesis.ListStreamConsumersOutput, bool) bool + }{arg1, arg2}) + stub := fake.ListStreamConsumersPagesStub + fakeReturns := fake.listStreamConsumersPagesReturns + fake.recordInvocation("ListStreamConsumersPages", []interface{}{arg1, arg2}) + fake.listStreamConsumersPagesMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesCallCount() int { + fake.listStreamConsumersPagesMutex.RLock() + defer fake.listStreamConsumersPagesMutex.RUnlock() + return len(fake.listStreamConsumersPagesArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesCalls(stub func(*kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool) error) { + fake.listStreamConsumersPagesMutex.Lock() + defer fake.listStreamConsumersPagesMutex.Unlock() + fake.ListStreamConsumersPagesStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesArgsForCall(i int) (*kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool) { + fake.listStreamConsumersPagesMutex.RLock() + defer fake.listStreamConsumersPagesMutex.RUnlock() + argsForCall := fake.listStreamConsumersPagesArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesReturns(result1 error) { + fake.listStreamConsumersPagesMutex.Lock() + defer fake.listStreamConsumersPagesMutex.Unlock() + fake.ListStreamConsumersPagesStub = nil + fake.listStreamConsumersPagesReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesReturnsOnCall(i int, result1 error) { + fake.listStreamConsumersPagesMutex.Lock() + defer fake.listStreamConsumersPagesMutex.Unlock() + fake.ListStreamConsumersPagesStub = nil + if fake.listStreamConsumersPagesReturnsOnCall == nil { + fake.listStreamConsumersPagesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.listStreamConsumersPagesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesWithContext(arg1 context.Context, arg2 *kinesis.ListStreamConsumersInput, arg3 func(*kinesis.ListStreamConsumersOutput, bool) bool, arg4 ...request.Option) error { + fake.listStreamConsumersPagesWithContextMutex.Lock() + ret, specificReturn := fake.listStreamConsumersPagesWithContextReturnsOnCall[len(fake.listStreamConsumersPagesWithContextArgsForCall)] + fake.listStreamConsumersPagesWithContextArgsForCall = append(fake.listStreamConsumersPagesWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.ListStreamConsumersInput + arg3 func(*kinesis.ListStreamConsumersOutput, bool) bool + arg4 []request.Option + }{arg1, arg2, arg3, arg4}) + stub := fake.ListStreamConsumersPagesWithContextStub + fakeReturns := fake.listStreamConsumersPagesWithContextReturns + fake.recordInvocation("ListStreamConsumersPagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) + fake.listStreamConsumersPagesWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesWithContextCallCount() int { + fake.listStreamConsumersPagesWithContextMutex.RLock() + defer fake.listStreamConsumersPagesWithContextMutex.RUnlock() + return len(fake.listStreamConsumersPagesWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesWithContextCalls(stub func(context.Context, *kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool, ...request.Option) error) { + fake.listStreamConsumersPagesWithContextMutex.Lock() + defer fake.listStreamConsumersPagesWithContextMutex.Unlock() + fake.ListStreamConsumersPagesWithContextStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesWithContextArgsForCall(i int) (context.Context, *kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool, []request.Option) { + fake.listStreamConsumersPagesWithContextMutex.RLock() + defer fake.listStreamConsumersPagesWithContextMutex.RUnlock() + argsForCall := fake.listStreamConsumersPagesWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesWithContextReturns(result1 error) { + fake.listStreamConsumersPagesWithContextMutex.Lock() + defer fake.listStreamConsumersPagesWithContextMutex.Unlock() + fake.ListStreamConsumersPagesWithContextStub = nil + fake.listStreamConsumersPagesWithContextReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersPagesWithContextReturnsOnCall(i int, result1 error) { + fake.listStreamConsumersPagesWithContextMutex.Lock() + defer fake.listStreamConsumersPagesWithContextMutex.Unlock() + fake.ListStreamConsumersPagesWithContextStub = nil + if fake.listStreamConsumersPagesWithContextReturnsOnCall == nil { + fake.listStreamConsumersPagesWithContextReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.listStreamConsumersPagesWithContextReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersRequest(arg1 *kinesis.ListStreamConsumersInput) (*request.Request, *kinesis.ListStreamConsumersOutput) { + fake.listStreamConsumersRequestMutex.Lock() + ret, specificReturn := fake.listStreamConsumersRequestReturnsOnCall[len(fake.listStreamConsumersRequestArgsForCall)] + fake.listStreamConsumersRequestArgsForCall = append(fake.listStreamConsumersRequestArgsForCall, struct { + arg1 *kinesis.ListStreamConsumersInput + }{arg1}) + stub := fake.ListStreamConsumersRequestStub + fakeReturns := fake.listStreamConsumersRequestReturns + fake.recordInvocation("ListStreamConsumersRequest", []interface{}{arg1}) + fake.listStreamConsumersRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersRequestCallCount() int { + fake.listStreamConsumersRequestMutex.RLock() + defer fake.listStreamConsumersRequestMutex.RUnlock() + return len(fake.listStreamConsumersRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamConsumersRequestCalls(stub func(*kinesis.ListStreamConsumersInput) (*request.Request, *kinesis.ListStreamConsumersOutput)) { + fake.listStreamConsumersRequestMutex.Lock() + defer fake.listStreamConsumersRequestMutex.Unlock() + fake.ListStreamConsumersRequestStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamConsumersRequestArgsForCall(i int) *kinesis.ListStreamConsumersInput { + fake.listStreamConsumersRequestMutex.RLock() + defer fake.listStreamConsumersRequestMutex.RUnlock() + argsForCall := fake.listStreamConsumersRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersRequestReturns(result1 *request.Request, result2 *kinesis.ListStreamConsumersOutput) { + fake.listStreamConsumersRequestMutex.Lock() + defer fake.listStreamConsumersRequestMutex.Unlock() + fake.ListStreamConsumersRequestStub = nil + fake.listStreamConsumersRequestReturns = struct { + result1 *request.Request + result2 *kinesis.ListStreamConsumersOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.ListStreamConsumersOutput) { + fake.listStreamConsumersRequestMutex.Lock() + defer fake.listStreamConsumersRequestMutex.Unlock() + fake.ListStreamConsumersRequestStub = nil + if fake.listStreamConsumersRequestReturnsOnCall == nil { + fake.listStreamConsumersRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.ListStreamConsumersOutput + }) + } + fake.listStreamConsumersRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.ListStreamConsumersOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersWithContext(arg1 context.Context, arg2 *kinesis.ListStreamConsumersInput, arg3 ...request.Option) (*kinesis.ListStreamConsumersOutput, error) { + fake.listStreamConsumersWithContextMutex.Lock() + ret, specificReturn := fake.listStreamConsumersWithContextReturnsOnCall[len(fake.listStreamConsumersWithContextArgsForCall)] + fake.listStreamConsumersWithContextArgsForCall = append(fake.listStreamConsumersWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.ListStreamConsumersInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.ListStreamConsumersWithContextStub + fakeReturns := fake.listStreamConsumersWithContextReturns + fake.recordInvocation("ListStreamConsumersWithContext", []interface{}{arg1, arg2, arg3}) + fake.listStreamConsumersWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersWithContextCallCount() int { + fake.listStreamConsumersWithContextMutex.RLock() + defer fake.listStreamConsumersWithContextMutex.RUnlock() + return len(fake.listStreamConsumersWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamConsumersWithContextCalls(stub func(context.Context, *kinesis.ListStreamConsumersInput, ...request.Option) (*kinesis.ListStreamConsumersOutput, error)) { + fake.listStreamConsumersWithContextMutex.Lock() + defer fake.listStreamConsumersWithContextMutex.Unlock() + fake.ListStreamConsumersWithContextStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamConsumersWithContextArgsForCall(i int) (context.Context, *kinesis.ListStreamConsumersInput, []request.Option) { + fake.listStreamConsumersWithContextMutex.RLock() + defer fake.listStreamConsumersWithContextMutex.RUnlock() + argsForCall := fake.listStreamConsumersWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) ListStreamConsumersWithContextReturns(result1 *kinesis.ListStreamConsumersOutput, result2 error) { + fake.listStreamConsumersWithContextMutex.Lock() + defer fake.listStreamConsumersWithContextMutex.Unlock() + fake.ListStreamConsumersWithContextStub = nil + fake.listStreamConsumersWithContextReturns = struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamConsumersWithContextReturnsOnCall(i int, result1 *kinesis.ListStreamConsumersOutput, result2 error) { + fake.listStreamConsumersWithContextMutex.Lock() + defer fake.listStreamConsumersWithContextMutex.Unlock() + fake.ListStreamConsumersWithContextStub = nil + if fake.listStreamConsumersWithContextReturnsOnCall == nil { + fake.listStreamConsumersWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + }) + } + fake.listStreamConsumersWithContextReturnsOnCall[i] = struct { + result1 *kinesis.ListStreamConsumersOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreams(arg1 *kinesis.ListStreamsInput) (*kinesis.ListStreamsOutput, error) { + fake.listStreamsMutex.Lock() + ret, specificReturn := fake.listStreamsReturnsOnCall[len(fake.listStreamsArgsForCall)] + fake.listStreamsArgsForCall = append(fake.listStreamsArgsForCall, struct { + arg1 *kinesis.ListStreamsInput + }{arg1}) + stub := fake.ListStreamsStub + fakeReturns := fake.listStreamsReturns + fake.recordInvocation("ListStreams", []interface{}{arg1}) + fake.listStreamsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListStreamsCallCount() int { + fake.listStreamsMutex.RLock() + defer fake.listStreamsMutex.RUnlock() + return len(fake.listStreamsArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamsCalls(stub func(*kinesis.ListStreamsInput) (*kinesis.ListStreamsOutput, error)) { + fake.listStreamsMutex.Lock() + defer fake.listStreamsMutex.Unlock() + fake.ListStreamsStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamsArgsForCall(i int) *kinesis.ListStreamsInput { + fake.listStreamsMutex.RLock() + defer fake.listStreamsMutex.RUnlock() + argsForCall := fake.listStreamsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListStreamsReturns(result1 *kinesis.ListStreamsOutput, result2 error) { + fake.listStreamsMutex.Lock() + defer fake.listStreamsMutex.Unlock() + fake.ListStreamsStub = nil + fake.listStreamsReturns = struct { + result1 *kinesis.ListStreamsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamsReturnsOnCall(i int, result1 *kinesis.ListStreamsOutput, result2 error) { + fake.listStreamsMutex.Lock() + defer fake.listStreamsMutex.Unlock() + fake.ListStreamsStub = nil + if fake.listStreamsReturnsOnCall == nil { + fake.listStreamsReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListStreamsOutput + result2 error + }) + } + fake.listStreamsReturnsOnCall[i] = struct { + result1 *kinesis.ListStreamsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamsPages(arg1 *kinesis.ListStreamsInput, arg2 func(*kinesis.ListStreamsOutput, bool) bool) error { + fake.listStreamsPagesMutex.Lock() + ret, specificReturn := fake.listStreamsPagesReturnsOnCall[len(fake.listStreamsPagesArgsForCall)] + fake.listStreamsPagesArgsForCall = append(fake.listStreamsPagesArgsForCall, struct { + arg1 *kinesis.ListStreamsInput + arg2 func(*kinesis.ListStreamsOutput, bool) bool + }{arg1, arg2}) + stub := fake.ListStreamsPagesStub + fakeReturns := fake.listStreamsPagesReturns + fake.recordInvocation("ListStreamsPages", []interface{}{arg1, arg2}) + fake.listStreamsPagesMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) ListStreamsPagesCallCount() int { + fake.listStreamsPagesMutex.RLock() + defer fake.listStreamsPagesMutex.RUnlock() + return len(fake.listStreamsPagesArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamsPagesCalls(stub func(*kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool) error) { + fake.listStreamsPagesMutex.Lock() + defer fake.listStreamsPagesMutex.Unlock() + fake.ListStreamsPagesStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamsPagesArgsForCall(i int) (*kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool) { + fake.listStreamsPagesMutex.RLock() + defer fake.listStreamsPagesMutex.RUnlock() + argsForCall := fake.listStreamsPagesArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeKinesisAPI) ListStreamsPagesReturns(result1 error) { + fake.listStreamsPagesMutex.Lock() + defer fake.listStreamsPagesMutex.Unlock() + fake.ListStreamsPagesStub = nil + fake.listStreamsPagesReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamsPagesReturnsOnCall(i int, result1 error) { + fake.listStreamsPagesMutex.Lock() + defer fake.listStreamsPagesMutex.Unlock() + fake.ListStreamsPagesStub = nil + if fake.listStreamsPagesReturnsOnCall == nil { + fake.listStreamsPagesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.listStreamsPagesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamsPagesWithContext(arg1 context.Context, arg2 *kinesis.ListStreamsInput, arg3 func(*kinesis.ListStreamsOutput, bool) bool, arg4 ...request.Option) error { + fake.listStreamsPagesWithContextMutex.Lock() + ret, specificReturn := fake.listStreamsPagesWithContextReturnsOnCall[len(fake.listStreamsPagesWithContextArgsForCall)] + fake.listStreamsPagesWithContextArgsForCall = append(fake.listStreamsPagesWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.ListStreamsInput + arg3 func(*kinesis.ListStreamsOutput, bool) bool + arg4 []request.Option + }{arg1, arg2, arg3, arg4}) + stub := fake.ListStreamsPagesWithContextStub + fakeReturns := fake.listStreamsPagesWithContextReturns + fake.recordInvocation("ListStreamsPagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) + fake.listStreamsPagesWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) ListStreamsPagesWithContextCallCount() int { + fake.listStreamsPagesWithContextMutex.RLock() + defer fake.listStreamsPagesWithContextMutex.RUnlock() + return len(fake.listStreamsPagesWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamsPagesWithContextCalls(stub func(context.Context, *kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool, ...request.Option) error) { + fake.listStreamsPagesWithContextMutex.Lock() + defer fake.listStreamsPagesWithContextMutex.Unlock() + fake.ListStreamsPagesWithContextStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamsPagesWithContextArgsForCall(i int) (context.Context, *kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool, []request.Option) { + fake.listStreamsPagesWithContextMutex.RLock() + defer fake.listStreamsPagesWithContextMutex.RUnlock() + argsForCall := fake.listStreamsPagesWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeKinesisAPI) ListStreamsPagesWithContextReturns(result1 error) { + fake.listStreamsPagesWithContextMutex.Lock() + defer fake.listStreamsPagesWithContextMutex.Unlock() + fake.ListStreamsPagesWithContextStub = nil + fake.listStreamsPagesWithContextReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamsPagesWithContextReturnsOnCall(i int, result1 error) { + fake.listStreamsPagesWithContextMutex.Lock() + defer fake.listStreamsPagesWithContextMutex.Unlock() + fake.ListStreamsPagesWithContextStub = nil + if fake.listStreamsPagesWithContextReturnsOnCall == nil { + fake.listStreamsPagesWithContextReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.listStreamsPagesWithContextReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) ListStreamsRequest(arg1 *kinesis.ListStreamsInput) (*request.Request, *kinesis.ListStreamsOutput) { + fake.listStreamsRequestMutex.Lock() + ret, specificReturn := fake.listStreamsRequestReturnsOnCall[len(fake.listStreamsRequestArgsForCall)] + fake.listStreamsRequestArgsForCall = append(fake.listStreamsRequestArgsForCall, struct { + arg1 *kinesis.ListStreamsInput + }{arg1}) + stub := fake.ListStreamsRequestStub + fakeReturns := fake.listStreamsRequestReturns + fake.recordInvocation("ListStreamsRequest", []interface{}{arg1}) + fake.listStreamsRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListStreamsRequestCallCount() int { + fake.listStreamsRequestMutex.RLock() + defer fake.listStreamsRequestMutex.RUnlock() + return len(fake.listStreamsRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamsRequestCalls(stub func(*kinesis.ListStreamsInput) (*request.Request, *kinesis.ListStreamsOutput)) { + fake.listStreamsRequestMutex.Lock() + defer fake.listStreamsRequestMutex.Unlock() + fake.ListStreamsRequestStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamsRequestArgsForCall(i int) *kinesis.ListStreamsInput { + fake.listStreamsRequestMutex.RLock() + defer fake.listStreamsRequestMutex.RUnlock() + argsForCall := fake.listStreamsRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListStreamsRequestReturns(result1 *request.Request, result2 *kinesis.ListStreamsOutput) { + fake.listStreamsRequestMutex.Lock() + defer fake.listStreamsRequestMutex.Unlock() + fake.ListStreamsRequestStub = nil + fake.listStreamsRequestReturns = struct { + result1 *request.Request + result2 *kinesis.ListStreamsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamsRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.ListStreamsOutput) { + fake.listStreamsRequestMutex.Lock() + defer fake.listStreamsRequestMutex.Unlock() + fake.ListStreamsRequestStub = nil + if fake.listStreamsRequestReturnsOnCall == nil { + fake.listStreamsRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.ListStreamsOutput + }) + } + fake.listStreamsRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.ListStreamsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamsWithContext(arg1 context.Context, arg2 *kinesis.ListStreamsInput, arg3 ...request.Option) (*kinesis.ListStreamsOutput, error) { + fake.listStreamsWithContextMutex.Lock() + ret, specificReturn := fake.listStreamsWithContextReturnsOnCall[len(fake.listStreamsWithContextArgsForCall)] + fake.listStreamsWithContextArgsForCall = append(fake.listStreamsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.ListStreamsInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.ListStreamsWithContextStub + fakeReturns := fake.listStreamsWithContextReturns + fake.recordInvocation("ListStreamsWithContext", []interface{}{arg1, arg2, arg3}) + fake.listStreamsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListStreamsWithContextCallCount() int { + fake.listStreamsWithContextMutex.RLock() + defer fake.listStreamsWithContextMutex.RUnlock() + return len(fake.listStreamsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) ListStreamsWithContextCalls(stub func(context.Context, *kinesis.ListStreamsInput, ...request.Option) (*kinesis.ListStreamsOutput, error)) { + fake.listStreamsWithContextMutex.Lock() + defer fake.listStreamsWithContextMutex.Unlock() + fake.ListStreamsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) ListStreamsWithContextArgsForCall(i int) (context.Context, *kinesis.ListStreamsInput, []request.Option) { + fake.listStreamsWithContextMutex.RLock() + defer fake.listStreamsWithContextMutex.RUnlock() + argsForCall := fake.listStreamsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) ListStreamsWithContextReturns(result1 *kinesis.ListStreamsOutput, result2 error) { + fake.listStreamsWithContextMutex.Lock() + defer fake.listStreamsWithContextMutex.Unlock() + fake.ListStreamsWithContextStub = nil + fake.listStreamsWithContextReturns = struct { + result1 *kinesis.ListStreamsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListStreamsWithContextReturnsOnCall(i int, result1 *kinesis.ListStreamsOutput, result2 error) { + fake.listStreamsWithContextMutex.Lock() + defer fake.listStreamsWithContextMutex.Unlock() + fake.ListStreamsWithContextStub = nil + if fake.listStreamsWithContextReturnsOnCall == nil { + fake.listStreamsWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListStreamsOutput + result2 error + }) + } + fake.listStreamsWithContextReturnsOnCall[i] = struct { + result1 *kinesis.ListStreamsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListTagsForStream(arg1 *kinesis.ListTagsForStreamInput) (*kinesis.ListTagsForStreamOutput, error) { + fake.listTagsForStreamMutex.Lock() + ret, specificReturn := fake.listTagsForStreamReturnsOnCall[len(fake.listTagsForStreamArgsForCall)] + fake.listTagsForStreamArgsForCall = append(fake.listTagsForStreamArgsForCall, struct { + arg1 *kinesis.ListTagsForStreamInput + }{arg1}) + stub := fake.ListTagsForStreamStub + fakeReturns := fake.listTagsForStreamReturns + fake.recordInvocation("ListTagsForStream", []interface{}{arg1}) + fake.listTagsForStreamMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListTagsForStreamCallCount() int { + fake.listTagsForStreamMutex.RLock() + defer fake.listTagsForStreamMutex.RUnlock() + return len(fake.listTagsForStreamArgsForCall) +} + +func (fake *FakeKinesisAPI) ListTagsForStreamCalls(stub func(*kinesis.ListTagsForStreamInput) (*kinesis.ListTagsForStreamOutput, error)) { + fake.listTagsForStreamMutex.Lock() + defer fake.listTagsForStreamMutex.Unlock() + fake.ListTagsForStreamStub = stub +} + +func (fake *FakeKinesisAPI) ListTagsForStreamArgsForCall(i int) *kinesis.ListTagsForStreamInput { + fake.listTagsForStreamMutex.RLock() + defer fake.listTagsForStreamMutex.RUnlock() + argsForCall := fake.listTagsForStreamArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListTagsForStreamReturns(result1 *kinesis.ListTagsForStreamOutput, result2 error) { + fake.listTagsForStreamMutex.Lock() + defer fake.listTagsForStreamMutex.Unlock() + fake.ListTagsForStreamStub = nil + fake.listTagsForStreamReturns = struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListTagsForStreamReturnsOnCall(i int, result1 *kinesis.ListTagsForStreamOutput, result2 error) { + fake.listTagsForStreamMutex.Lock() + defer fake.listTagsForStreamMutex.Unlock() + fake.ListTagsForStreamStub = nil + if fake.listTagsForStreamReturnsOnCall == nil { + fake.listTagsForStreamReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + }) + } + fake.listTagsForStreamReturnsOnCall[i] = struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListTagsForStreamRequest(arg1 *kinesis.ListTagsForStreamInput) (*request.Request, *kinesis.ListTagsForStreamOutput) { + fake.listTagsForStreamRequestMutex.Lock() + ret, specificReturn := fake.listTagsForStreamRequestReturnsOnCall[len(fake.listTagsForStreamRequestArgsForCall)] + fake.listTagsForStreamRequestArgsForCall = append(fake.listTagsForStreamRequestArgsForCall, struct { + arg1 *kinesis.ListTagsForStreamInput + }{arg1}) + stub := fake.ListTagsForStreamRequestStub + fakeReturns := fake.listTagsForStreamRequestReturns + fake.recordInvocation("ListTagsForStreamRequest", []interface{}{arg1}) + fake.listTagsForStreamRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListTagsForStreamRequestCallCount() int { + fake.listTagsForStreamRequestMutex.RLock() + defer fake.listTagsForStreamRequestMutex.RUnlock() + return len(fake.listTagsForStreamRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) ListTagsForStreamRequestCalls(stub func(*kinesis.ListTagsForStreamInput) (*request.Request, *kinesis.ListTagsForStreamOutput)) { + fake.listTagsForStreamRequestMutex.Lock() + defer fake.listTagsForStreamRequestMutex.Unlock() + fake.ListTagsForStreamRequestStub = stub +} + +func (fake *FakeKinesisAPI) ListTagsForStreamRequestArgsForCall(i int) *kinesis.ListTagsForStreamInput { + fake.listTagsForStreamRequestMutex.RLock() + defer fake.listTagsForStreamRequestMutex.RUnlock() + argsForCall := fake.listTagsForStreamRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) ListTagsForStreamRequestReturns(result1 *request.Request, result2 *kinesis.ListTagsForStreamOutput) { + fake.listTagsForStreamRequestMutex.Lock() + defer fake.listTagsForStreamRequestMutex.Unlock() + fake.ListTagsForStreamRequestStub = nil + fake.listTagsForStreamRequestReturns = struct { + result1 *request.Request + result2 *kinesis.ListTagsForStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListTagsForStreamRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.ListTagsForStreamOutput) { + fake.listTagsForStreamRequestMutex.Lock() + defer fake.listTagsForStreamRequestMutex.Unlock() + fake.ListTagsForStreamRequestStub = nil + if fake.listTagsForStreamRequestReturnsOnCall == nil { + fake.listTagsForStreamRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.ListTagsForStreamOutput + }) + } + fake.listTagsForStreamRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.ListTagsForStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListTagsForStreamWithContext(arg1 context.Context, arg2 *kinesis.ListTagsForStreamInput, arg3 ...request.Option) (*kinesis.ListTagsForStreamOutput, error) { + fake.listTagsForStreamWithContextMutex.Lock() + ret, specificReturn := fake.listTagsForStreamWithContextReturnsOnCall[len(fake.listTagsForStreamWithContextArgsForCall)] + fake.listTagsForStreamWithContextArgsForCall = append(fake.listTagsForStreamWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.ListTagsForStreamInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.ListTagsForStreamWithContextStub + fakeReturns := fake.listTagsForStreamWithContextReturns + fake.recordInvocation("ListTagsForStreamWithContext", []interface{}{arg1, arg2, arg3}) + fake.listTagsForStreamWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) ListTagsForStreamWithContextCallCount() int { + fake.listTagsForStreamWithContextMutex.RLock() + defer fake.listTagsForStreamWithContextMutex.RUnlock() + return len(fake.listTagsForStreamWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) ListTagsForStreamWithContextCalls(stub func(context.Context, *kinesis.ListTagsForStreamInput, ...request.Option) (*kinesis.ListTagsForStreamOutput, error)) { + fake.listTagsForStreamWithContextMutex.Lock() + defer fake.listTagsForStreamWithContextMutex.Unlock() + fake.ListTagsForStreamWithContextStub = stub +} + +func (fake *FakeKinesisAPI) ListTagsForStreamWithContextArgsForCall(i int) (context.Context, *kinesis.ListTagsForStreamInput, []request.Option) { + fake.listTagsForStreamWithContextMutex.RLock() + defer fake.listTagsForStreamWithContextMutex.RUnlock() + argsForCall := fake.listTagsForStreamWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) ListTagsForStreamWithContextReturns(result1 *kinesis.ListTagsForStreamOutput, result2 error) { + fake.listTagsForStreamWithContextMutex.Lock() + defer fake.listTagsForStreamWithContextMutex.Unlock() + fake.ListTagsForStreamWithContextStub = nil + fake.listTagsForStreamWithContextReturns = struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) ListTagsForStreamWithContextReturnsOnCall(i int, result1 *kinesis.ListTagsForStreamOutput, result2 error) { + fake.listTagsForStreamWithContextMutex.Lock() + defer fake.listTagsForStreamWithContextMutex.Unlock() + fake.ListTagsForStreamWithContextStub = nil + if fake.listTagsForStreamWithContextReturnsOnCall == nil { + fake.listTagsForStreamWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + }) + } + fake.listTagsForStreamWithContextReturnsOnCall[i] = struct { + result1 *kinesis.ListTagsForStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) MergeShards(arg1 *kinesis.MergeShardsInput) (*kinesis.MergeShardsOutput, error) { + fake.mergeShardsMutex.Lock() + ret, specificReturn := fake.mergeShardsReturnsOnCall[len(fake.mergeShardsArgsForCall)] + fake.mergeShardsArgsForCall = append(fake.mergeShardsArgsForCall, struct { + arg1 *kinesis.MergeShardsInput + }{arg1}) + stub := fake.MergeShardsStub + fakeReturns := fake.mergeShardsReturns + fake.recordInvocation("MergeShards", []interface{}{arg1}) + fake.mergeShardsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) MergeShardsCallCount() int { + fake.mergeShardsMutex.RLock() + defer fake.mergeShardsMutex.RUnlock() + return len(fake.mergeShardsArgsForCall) +} + +func (fake *FakeKinesisAPI) MergeShardsCalls(stub func(*kinesis.MergeShardsInput) (*kinesis.MergeShardsOutput, error)) { + fake.mergeShardsMutex.Lock() + defer fake.mergeShardsMutex.Unlock() + fake.MergeShardsStub = stub +} + +func (fake *FakeKinesisAPI) MergeShardsArgsForCall(i int) *kinesis.MergeShardsInput { + fake.mergeShardsMutex.RLock() + defer fake.mergeShardsMutex.RUnlock() + argsForCall := fake.mergeShardsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) MergeShardsReturns(result1 *kinesis.MergeShardsOutput, result2 error) { + fake.mergeShardsMutex.Lock() + defer fake.mergeShardsMutex.Unlock() + fake.MergeShardsStub = nil + fake.mergeShardsReturns = struct { + result1 *kinesis.MergeShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) MergeShardsReturnsOnCall(i int, result1 *kinesis.MergeShardsOutput, result2 error) { + fake.mergeShardsMutex.Lock() + defer fake.mergeShardsMutex.Unlock() + fake.MergeShardsStub = nil + if fake.mergeShardsReturnsOnCall == nil { + fake.mergeShardsReturnsOnCall = make(map[int]struct { + result1 *kinesis.MergeShardsOutput + result2 error + }) + } + fake.mergeShardsReturnsOnCall[i] = struct { + result1 *kinesis.MergeShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) MergeShardsRequest(arg1 *kinesis.MergeShardsInput) (*request.Request, *kinesis.MergeShardsOutput) { + fake.mergeShardsRequestMutex.Lock() + ret, specificReturn := fake.mergeShardsRequestReturnsOnCall[len(fake.mergeShardsRequestArgsForCall)] + fake.mergeShardsRequestArgsForCall = append(fake.mergeShardsRequestArgsForCall, struct { + arg1 *kinesis.MergeShardsInput + }{arg1}) + stub := fake.MergeShardsRequestStub + fakeReturns := fake.mergeShardsRequestReturns + fake.recordInvocation("MergeShardsRequest", []interface{}{arg1}) + fake.mergeShardsRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) MergeShardsRequestCallCount() int { + fake.mergeShardsRequestMutex.RLock() + defer fake.mergeShardsRequestMutex.RUnlock() + return len(fake.mergeShardsRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) MergeShardsRequestCalls(stub func(*kinesis.MergeShardsInput) (*request.Request, *kinesis.MergeShardsOutput)) { + fake.mergeShardsRequestMutex.Lock() + defer fake.mergeShardsRequestMutex.Unlock() + fake.MergeShardsRequestStub = stub +} + +func (fake *FakeKinesisAPI) MergeShardsRequestArgsForCall(i int) *kinesis.MergeShardsInput { + fake.mergeShardsRequestMutex.RLock() + defer fake.mergeShardsRequestMutex.RUnlock() + argsForCall := fake.mergeShardsRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) MergeShardsRequestReturns(result1 *request.Request, result2 *kinesis.MergeShardsOutput) { + fake.mergeShardsRequestMutex.Lock() + defer fake.mergeShardsRequestMutex.Unlock() + fake.MergeShardsRequestStub = nil + fake.mergeShardsRequestReturns = struct { + result1 *request.Request + result2 *kinesis.MergeShardsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) MergeShardsRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.MergeShardsOutput) { + fake.mergeShardsRequestMutex.Lock() + defer fake.mergeShardsRequestMutex.Unlock() + fake.MergeShardsRequestStub = nil + if fake.mergeShardsRequestReturnsOnCall == nil { + fake.mergeShardsRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.MergeShardsOutput + }) + } + fake.mergeShardsRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.MergeShardsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) MergeShardsWithContext(arg1 context.Context, arg2 *kinesis.MergeShardsInput, arg3 ...request.Option) (*kinesis.MergeShardsOutput, error) { + fake.mergeShardsWithContextMutex.Lock() + ret, specificReturn := fake.mergeShardsWithContextReturnsOnCall[len(fake.mergeShardsWithContextArgsForCall)] + fake.mergeShardsWithContextArgsForCall = append(fake.mergeShardsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.MergeShardsInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.MergeShardsWithContextStub + fakeReturns := fake.mergeShardsWithContextReturns + fake.recordInvocation("MergeShardsWithContext", []interface{}{arg1, arg2, arg3}) + fake.mergeShardsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) MergeShardsWithContextCallCount() int { + fake.mergeShardsWithContextMutex.RLock() + defer fake.mergeShardsWithContextMutex.RUnlock() + return len(fake.mergeShardsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) MergeShardsWithContextCalls(stub func(context.Context, *kinesis.MergeShardsInput, ...request.Option) (*kinesis.MergeShardsOutput, error)) { + fake.mergeShardsWithContextMutex.Lock() + defer fake.mergeShardsWithContextMutex.Unlock() + fake.MergeShardsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) MergeShardsWithContextArgsForCall(i int) (context.Context, *kinesis.MergeShardsInput, []request.Option) { + fake.mergeShardsWithContextMutex.RLock() + defer fake.mergeShardsWithContextMutex.RUnlock() + argsForCall := fake.mergeShardsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) MergeShardsWithContextReturns(result1 *kinesis.MergeShardsOutput, result2 error) { + fake.mergeShardsWithContextMutex.Lock() + defer fake.mergeShardsWithContextMutex.Unlock() + fake.MergeShardsWithContextStub = nil + fake.mergeShardsWithContextReturns = struct { + result1 *kinesis.MergeShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) MergeShardsWithContextReturnsOnCall(i int, result1 *kinesis.MergeShardsOutput, result2 error) { + fake.mergeShardsWithContextMutex.Lock() + defer fake.mergeShardsWithContextMutex.Unlock() + fake.MergeShardsWithContextStub = nil + if fake.mergeShardsWithContextReturnsOnCall == nil { + fake.mergeShardsWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.MergeShardsOutput + result2 error + }) + } + fake.mergeShardsWithContextReturnsOnCall[i] = struct { + result1 *kinesis.MergeShardsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecord(arg1 *kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) { + fake.putRecordMutex.Lock() + ret, specificReturn := fake.putRecordReturnsOnCall[len(fake.putRecordArgsForCall)] + fake.putRecordArgsForCall = append(fake.putRecordArgsForCall, struct { + arg1 *kinesis.PutRecordInput + }{arg1}) + stub := fake.PutRecordStub + fakeReturns := fake.putRecordReturns + fake.recordInvocation("PutRecord", []interface{}{arg1}) + fake.putRecordMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) PutRecordCallCount() int { + fake.putRecordMutex.RLock() + defer fake.putRecordMutex.RUnlock() + return len(fake.putRecordArgsForCall) +} + +func (fake *FakeKinesisAPI) PutRecordCalls(stub func(*kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error)) { + fake.putRecordMutex.Lock() + defer fake.putRecordMutex.Unlock() + fake.PutRecordStub = stub +} + +func (fake *FakeKinesisAPI) PutRecordArgsForCall(i int) *kinesis.PutRecordInput { + fake.putRecordMutex.RLock() + defer fake.putRecordMutex.RUnlock() + argsForCall := fake.putRecordArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) PutRecordReturns(result1 *kinesis.PutRecordOutput, result2 error) { + fake.putRecordMutex.Lock() + defer fake.putRecordMutex.Unlock() + fake.PutRecordStub = nil + fake.putRecordReturns = struct { + result1 *kinesis.PutRecordOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordReturnsOnCall(i int, result1 *kinesis.PutRecordOutput, result2 error) { + fake.putRecordMutex.Lock() + defer fake.putRecordMutex.Unlock() + fake.PutRecordStub = nil + if fake.putRecordReturnsOnCall == nil { + fake.putRecordReturnsOnCall = make(map[int]struct { + result1 *kinesis.PutRecordOutput + result2 error + }) + } + fake.putRecordReturnsOnCall[i] = struct { + result1 *kinesis.PutRecordOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordRequest(arg1 *kinesis.PutRecordInput) (*request.Request, *kinesis.PutRecordOutput) { + fake.putRecordRequestMutex.Lock() + ret, specificReturn := fake.putRecordRequestReturnsOnCall[len(fake.putRecordRequestArgsForCall)] + fake.putRecordRequestArgsForCall = append(fake.putRecordRequestArgsForCall, struct { + arg1 *kinesis.PutRecordInput + }{arg1}) + stub := fake.PutRecordRequestStub + fakeReturns := fake.putRecordRequestReturns + fake.recordInvocation("PutRecordRequest", []interface{}{arg1}) + fake.putRecordRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) PutRecordRequestCallCount() int { + fake.putRecordRequestMutex.RLock() + defer fake.putRecordRequestMutex.RUnlock() + return len(fake.putRecordRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) PutRecordRequestCalls(stub func(*kinesis.PutRecordInput) (*request.Request, *kinesis.PutRecordOutput)) { + fake.putRecordRequestMutex.Lock() + defer fake.putRecordRequestMutex.Unlock() + fake.PutRecordRequestStub = stub +} + +func (fake *FakeKinesisAPI) PutRecordRequestArgsForCall(i int) *kinesis.PutRecordInput { + fake.putRecordRequestMutex.RLock() + defer fake.putRecordRequestMutex.RUnlock() + argsForCall := fake.putRecordRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) PutRecordRequestReturns(result1 *request.Request, result2 *kinesis.PutRecordOutput) { + fake.putRecordRequestMutex.Lock() + defer fake.putRecordRequestMutex.Unlock() + fake.PutRecordRequestStub = nil + fake.putRecordRequestReturns = struct { + result1 *request.Request + result2 *kinesis.PutRecordOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.PutRecordOutput) { + fake.putRecordRequestMutex.Lock() + defer fake.putRecordRequestMutex.Unlock() + fake.PutRecordRequestStub = nil + if fake.putRecordRequestReturnsOnCall == nil { + fake.putRecordRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.PutRecordOutput + }) + } + fake.putRecordRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.PutRecordOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordWithContext(arg1 context.Context, arg2 *kinesis.PutRecordInput, arg3 ...request.Option) (*kinesis.PutRecordOutput, error) { + fake.putRecordWithContextMutex.Lock() + ret, specificReturn := fake.putRecordWithContextReturnsOnCall[len(fake.putRecordWithContextArgsForCall)] + fake.putRecordWithContextArgsForCall = append(fake.putRecordWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.PutRecordInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.PutRecordWithContextStub + fakeReturns := fake.putRecordWithContextReturns + fake.recordInvocation("PutRecordWithContext", []interface{}{arg1, arg2, arg3}) + fake.putRecordWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) PutRecordWithContextCallCount() int { + fake.putRecordWithContextMutex.RLock() + defer fake.putRecordWithContextMutex.RUnlock() + return len(fake.putRecordWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) PutRecordWithContextCalls(stub func(context.Context, *kinesis.PutRecordInput, ...request.Option) (*kinesis.PutRecordOutput, error)) { + fake.putRecordWithContextMutex.Lock() + defer fake.putRecordWithContextMutex.Unlock() + fake.PutRecordWithContextStub = stub +} + +func (fake *FakeKinesisAPI) PutRecordWithContextArgsForCall(i int) (context.Context, *kinesis.PutRecordInput, []request.Option) { + fake.putRecordWithContextMutex.RLock() + defer fake.putRecordWithContextMutex.RUnlock() + argsForCall := fake.putRecordWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) PutRecordWithContextReturns(result1 *kinesis.PutRecordOutput, result2 error) { + fake.putRecordWithContextMutex.Lock() + defer fake.putRecordWithContextMutex.Unlock() + fake.PutRecordWithContextStub = nil + fake.putRecordWithContextReturns = struct { + result1 *kinesis.PutRecordOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordWithContextReturnsOnCall(i int, result1 *kinesis.PutRecordOutput, result2 error) { + fake.putRecordWithContextMutex.Lock() + defer fake.putRecordWithContextMutex.Unlock() + fake.PutRecordWithContextStub = nil + if fake.putRecordWithContextReturnsOnCall == nil { + fake.putRecordWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.PutRecordOutput + result2 error + }) + } + fake.putRecordWithContextReturnsOnCall[i] = struct { + result1 *kinesis.PutRecordOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecords(arg1 *kinesis.PutRecordsInput) (*kinesis.PutRecordsOutput, error) { + fake.putRecordsMutex.Lock() + ret, specificReturn := fake.putRecordsReturnsOnCall[len(fake.putRecordsArgsForCall)] + fake.putRecordsArgsForCall = append(fake.putRecordsArgsForCall, struct { + arg1 *kinesis.PutRecordsInput + }{arg1}) + stub := fake.PutRecordsStub + fakeReturns := fake.putRecordsReturns + fake.recordInvocation("PutRecords", []interface{}{arg1}) + fake.putRecordsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) PutRecordsCallCount() int { + fake.putRecordsMutex.RLock() + defer fake.putRecordsMutex.RUnlock() + return len(fake.putRecordsArgsForCall) +} + +func (fake *FakeKinesisAPI) PutRecordsCalls(stub func(*kinesis.PutRecordsInput) (*kinesis.PutRecordsOutput, error)) { + fake.putRecordsMutex.Lock() + defer fake.putRecordsMutex.Unlock() + fake.PutRecordsStub = stub +} + +func (fake *FakeKinesisAPI) PutRecordsArgsForCall(i int) *kinesis.PutRecordsInput { + fake.putRecordsMutex.RLock() + defer fake.putRecordsMutex.RUnlock() + argsForCall := fake.putRecordsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) PutRecordsReturns(result1 *kinesis.PutRecordsOutput, result2 error) { + fake.putRecordsMutex.Lock() + defer fake.putRecordsMutex.Unlock() + fake.PutRecordsStub = nil + fake.putRecordsReturns = struct { + result1 *kinesis.PutRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordsReturnsOnCall(i int, result1 *kinesis.PutRecordsOutput, result2 error) { + fake.putRecordsMutex.Lock() + defer fake.putRecordsMutex.Unlock() + fake.PutRecordsStub = nil + if fake.putRecordsReturnsOnCall == nil { + fake.putRecordsReturnsOnCall = make(map[int]struct { + result1 *kinesis.PutRecordsOutput + result2 error + }) + } + fake.putRecordsReturnsOnCall[i] = struct { + result1 *kinesis.PutRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordsRequest(arg1 *kinesis.PutRecordsInput) (*request.Request, *kinesis.PutRecordsOutput) { + fake.putRecordsRequestMutex.Lock() + ret, specificReturn := fake.putRecordsRequestReturnsOnCall[len(fake.putRecordsRequestArgsForCall)] + fake.putRecordsRequestArgsForCall = append(fake.putRecordsRequestArgsForCall, struct { + arg1 *kinesis.PutRecordsInput + }{arg1}) + stub := fake.PutRecordsRequestStub + fakeReturns := fake.putRecordsRequestReturns + fake.recordInvocation("PutRecordsRequest", []interface{}{arg1}) + fake.putRecordsRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) PutRecordsRequestCallCount() int { + fake.putRecordsRequestMutex.RLock() + defer fake.putRecordsRequestMutex.RUnlock() + return len(fake.putRecordsRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) PutRecordsRequestCalls(stub func(*kinesis.PutRecordsInput) (*request.Request, *kinesis.PutRecordsOutput)) { + fake.putRecordsRequestMutex.Lock() + defer fake.putRecordsRequestMutex.Unlock() + fake.PutRecordsRequestStub = stub +} + +func (fake *FakeKinesisAPI) PutRecordsRequestArgsForCall(i int) *kinesis.PutRecordsInput { + fake.putRecordsRequestMutex.RLock() + defer fake.putRecordsRequestMutex.RUnlock() + argsForCall := fake.putRecordsRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) PutRecordsRequestReturns(result1 *request.Request, result2 *kinesis.PutRecordsOutput) { + fake.putRecordsRequestMutex.Lock() + defer fake.putRecordsRequestMutex.Unlock() + fake.PutRecordsRequestStub = nil + fake.putRecordsRequestReturns = struct { + result1 *request.Request + result2 *kinesis.PutRecordsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordsRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.PutRecordsOutput) { + fake.putRecordsRequestMutex.Lock() + defer fake.putRecordsRequestMutex.Unlock() + fake.PutRecordsRequestStub = nil + if fake.putRecordsRequestReturnsOnCall == nil { + fake.putRecordsRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.PutRecordsOutput + }) + } + fake.putRecordsRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.PutRecordsOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordsWithContext(arg1 context.Context, arg2 *kinesis.PutRecordsInput, arg3 ...request.Option) (*kinesis.PutRecordsOutput, error) { + fake.putRecordsWithContextMutex.Lock() + ret, specificReturn := fake.putRecordsWithContextReturnsOnCall[len(fake.putRecordsWithContextArgsForCall)] + fake.putRecordsWithContextArgsForCall = append(fake.putRecordsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.PutRecordsInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.PutRecordsWithContextStub + fakeReturns := fake.putRecordsWithContextReturns + fake.recordInvocation("PutRecordsWithContext", []interface{}{arg1, arg2, arg3}) + fake.putRecordsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) PutRecordsWithContextCallCount() int { + fake.putRecordsWithContextMutex.RLock() + defer fake.putRecordsWithContextMutex.RUnlock() + return len(fake.putRecordsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) PutRecordsWithContextCalls(stub func(context.Context, *kinesis.PutRecordsInput, ...request.Option) (*kinesis.PutRecordsOutput, error)) { + fake.putRecordsWithContextMutex.Lock() + defer fake.putRecordsWithContextMutex.Unlock() + fake.PutRecordsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) PutRecordsWithContextArgsForCall(i int) (context.Context, *kinesis.PutRecordsInput, []request.Option) { + fake.putRecordsWithContextMutex.RLock() + defer fake.putRecordsWithContextMutex.RUnlock() + argsForCall := fake.putRecordsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) PutRecordsWithContextReturns(result1 *kinesis.PutRecordsOutput, result2 error) { + fake.putRecordsWithContextMutex.Lock() + defer fake.putRecordsWithContextMutex.Unlock() + fake.PutRecordsWithContextStub = nil + fake.putRecordsWithContextReturns = struct { + result1 *kinesis.PutRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) PutRecordsWithContextReturnsOnCall(i int, result1 *kinesis.PutRecordsOutput, result2 error) { + fake.putRecordsWithContextMutex.Lock() + defer fake.putRecordsWithContextMutex.Unlock() + fake.PutRecordsWithContextStub = nil + if fake.putRecordsWithContextReturnsOnCall == nil { + fake.putRecordsWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.PutRecordsOutput + result2 error + }) + } + fake.putRecordsWithContextReturnsOnCall[i] = struct { + result1 *kinesis.PutRecordsOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumer(arg1 *kinesis.RegisterStreamConsumerInput) (*kinesis.RegisterStreamConsumerOutput, error) { + fake.registerStreamConsumerMutex.Lock() + ret, specificReturn := fake.registerStreamConsumerReturnsOnCall[len(fake.registerStreamConsumerArgsForCall)] + fake.registerStreamConsumerArgsForCall = append(fake.registerStreamConsumerArgsForCall, struct { + arg1 *kinesis.RegisterStreamConsumerInput + }{arg1}) + stub := fake.RegisterStreamConsumerStub + fakeReturns := fake.registerStreamConsumerReturns + fake.recordInvocation("RegisterStreamConsumer", []interface{}{arg1}) + fake.registerStreamConsumerMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerCallCount() int { + fake.registerStreamConsumerMutex.RLock() + defer fake.registerStreamConsumerMutex.RUnlock() + return len(fake.registerStreamConsumerArgsForCall) +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerCalls(stub func(*kinesis.RegisterStreamConsumerInput) (*kinesis.RegisterStreamConsumerOutput, error)) { + fake.registerStreamConsumerMutex.Lock() + defer fake.registerStreamConsumerMutex.Unlock() + fake.RegisterStreamConsumerStub = stub +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerArgsForCall(i int) *kinesis.RegisterStreamConsumerInput { + fake.registerStreamConsumerMutex.RLock() + defer fake.registerStreamConsumerMutex.RUnlock() + argsForCall := fake.registerStreamConsumerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerReturns(result1 *kinesis.RegisterStreamConsumerOutput, result2 error) { + fake.registerStreamConsumerMutex.Lock() + defer fake.registerStreamConsumerMutex.Unlock() + fake.RegisterStreamConsumerStub = nil + fake.registerStreamConsumerReturns = struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerReturnsOnCall(i int, result1 *kinesis.RegisterStreamConsumerOutput, result2 error) { + fake.registerStreamConsumerMutex.Lock() + defer fake.registerStreamConsumerMutex.Unlock() + fake.RegisterStreamConsumerStub = nil + if fake.registerStreamConsumerReturnsOnCall == nil { + fake.registerStreamConsumerReturnsOnCall = make(map[int]struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + }) + } + fake.registerStreamConsumerReturnsOnCall[i] = struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerRequest(arg1 *kinesis.RegisterStreamConsumerInput) (*request.Request, *kinesis.RegisterStreamConsumerOutput) { + fake.registerStreamConsumerRequestMutex.Lock() + ret, specificReturn := fake.registerStreamConsumerRequestReturnsOnCall[len(fake.registerStreamConsumerRequestArgsForCall)] + fake.registerStreamConsumerRequestArgsForCall = append(fake.registerStreamConsumerRequestArgsForCall, struct { + arg1 *kinesis.RegisterStreamConsumerInput + }{arg1}) + stub := fake.RegisterStreamConsumerRequestStub + fakeReturns := fake.registerStreamConsumerRequestReturns + fake.recordInvocation("RegisterStreamConsumerRequest", []interface{}{arg1}) + fake.registerStreamConsumerRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerRequestCallCount() int { + fake.registerStreamConsumerRequestMutex.RLock() + defer fake.registerStreamConsumerRequestMutex.RUnlock() + return len(fake.registerStreamConsumerRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerRequestCalls(stub func(*kinesis.RegisterStreamConsumerInput) (*request.Request, *kinesis.RegisterStreamConsumerOutput)) { + fake.registerStreamConsumerRequestMutex.Lock() + defer fake.registerStreamConsumerRequestMutex.Unlock() + fake.RegisterStreamConsumerRequestStub = stub +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerRequestArgsForCall(i int) *kinesis.RegisterStreamConsumerInput { + fake.registerStreamConsumerRequestMutex.RLock() + defer fake.registerStreamConsumerRequestMutex.RUnlock() + argsForCall := fake.registerStreamConsumerRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerRequestReturns(result1 *request.Request, result2 *kinesis.RegisterStreamConsumerOutput) { + fake.registerStreamConsumerRequestMutex.Lock() + defer fake.registerStreamConsumerRequestMutex.Unlock() + fake.RegisterStreamConsumerRequestStub = nil + fake.registerStreamConsumerRequestReturns = struct { + result1 *request.Request + result2 *kinesis.RegisterStreamConsumerOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.RegisterStreamConsumerOutput) { + fake.registerStreamConsumerRequestMutex.Lock() + defer fake.registerStreamConsumerRequestMutex.Unlock() + fake.RegisterStreamConsumerRequestStub = nil + if fake.registerStreamConsumerRequestReturnsOnCall == nil { + fake.registerStreamConsumerRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.RegisterStreamConsumerOutput + }) + } + fake.registerStreamConsumerRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.RegisterStreamConsumerOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerWithContext(arg1 context.Context, arg2 *kinesis.RegisterStreamConsumerInput, arg3 ...request.Option) (*kinesis.RegisterStreamConsumerOutput, error) { + fake.registerStreamConsumerWithContextMutex.Lock() + ret, specificReturn := fake.registerStreamConsumerWithContextReturnsOnCall[len(fake.registerStreamConsumerWithContextArgsForCall)] + fake.registerStreamConsumerWithContextArgsForCall = append(fake.registerStreamConsumerWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.RegisterStreamConsumerInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.RegisterStreamConsumerWithContextStub + fakeReturns := fake.registerStreamConsumerWithContextReturns + fake.recordInvocation("RegisterStreamConsumerWithContext", []interface{}{arg1, arg2, arg3}) + fake.registerStreamConsumerWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerWithContextCallCount() int { + fake.registerStreamConsumerWithContextMutex.RLock() + defer fake.registerStreamConsumerWithContextMutex.RUnlock() + return len(fake.registerStreamConsumerWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerWithContextCalls(stub func(context.Context, *kinesis.RegisterStreamConsumerInput, ...request.Option) (*kinesis.RegisterStreamConsumerOutput, error)) { + fake.registerStreamConsumerWithContextMutex.Lock() + defer fake.registerStreamConsumerWithContextMutex.Unlock() + fake.RegisterStreamConsumerWithContextStub = stub +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerWithContextArgsForCall(i int) (context.Context, *kinesis.RegisterStreamConsumerInput, []request.Option) { + fake.registerStreamConsumerWithContextMutex.RLock() + defer fake.registerStreamConsumerWithContextMutex.RUnlock() + argsForCall := fake.registerStreamConsumerWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerWithContextReturns(result1 *kinesis.RegisterStreamConsumerOutput, result2 error) { + fake.registerStreamConsumerWithContextMutex.Lock() + defer fake.registerStreamConsumerWithContextMutex.Unlock() + fake.RegisterStreamConsumerWithContextStub = nil + fake.registerStreamConsumerWithContextReturns = struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RegisterStreamConsumerWithContextReturnsOnCall(i int, result1 *kinesis.RegisterStreamConsumerOutput, result2 error) { + fake.registerStreamConsumerWithContextMutex.Lock() + defer fake.registerStreamConsumerWithContextMutex.Unlock() + fake.RegisterStreamConsumerWithContextStub = nil + if fake.registerStreamConsumerWithContextReturnsOnCall == nil { + fake.registerStreamConsumerWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + }) + } + fake.registerStreamConsumerWithContextReturnsOnCall[i] = struct { + result1 *kinesis.RegisterStreamConsumerOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStream(arg1 *kinesis.RemoveTagsFromStreamInput) (*kinesis.RemoveTagsFromStreamOutput, error) { + fake.removeTagsFromStreamMutex.Lock() + ret, specificReturn := fake.removeTagsFromStreamReturnsOnCall[len(fake.removeTagsFromStreamArgsForCall)] + fake.removeTagsFromStreamArgsForCall = append(fake.removeTagsFromStreamArgsForCall, struct { + arg1 *kinesis.RemoveTagsFromStreamInput + }{arg1}) + stub := fake.RemoveTagsFromStreamStub + fakeReturns := fake.removeTagsFromStreamReturns + fake.recordInvocation("RemoveTagsFromStream", []interface{}{arg1}) + fake.removeTagsFromStreamMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamCallCount() int { + fake.removeTagsFromStreamMutex.RLock() + defer fake.removeTagsFromStreamMutex.RUnlock() + return len(fake.removeTagsFromStreamArgsForCall) +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamCalls(stub func(*kinesis.RemoveTagsFromStreamInput) (*kinesis.RemoveTagsFromStreamOutput, error)) { + fake.removeTagsFromStreamMutex.Lock() + defer fake.removeTagsFromStreamMutex.Unlock() + fake.RemoveTagsFromStreamStub = stub +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamArgsForCall(i int) *kinesis.RemoveTagsFromStreamInput { + fake.removeTagsFromStreamMutex.RLock() + defer fake.removeTagsFromStreamMutex.RUnlock() + argsForCall := fake.removeTagsFromStreamArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamReturns(result1 *kinesis.RemoveTagsFromStreamOutput, result2 error) { + fake.removeTagsFromStreamMutex.Lock() + defer fake.removeTagsFromStreamMutex.Unlock() + fake.RemoveTagsFromStreamStub = nil + fake.removeTagsFromStreamReturns = struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamReturnsOnCall(i int, result1 *kinesis.RemoveTagsFromStreamOutput, result2 error) { + fake.removeTagsFromStreamMutex.Lock() + defer fake.removeTagsFromStreamMutex.Unlock() + fake.RemoveTagsFromStreamStub = nil + if fake.removeTagsFromStreamReturnsOnCall == nil { + fake.removeTagsFromStreamReturnsOnCall = make(map[int]struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + }) + } + fake.removeTagsFromStreamReturnsOnCall[i] = struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamRequest(arg1 *kinesis.RemoveTagsFromStreamInput) (*request.Request, *kinesis.RemoveTagsFromStreamOutput) { + fake.removeTagsFromStreamRequestMutex.Lock() + ret, specificReturn := fake.removeTagsFromStreamRequestReturnsOnCall[len(fake.removeTagsFromStreamRequestArgsForCall)] + fake.removeTagsFromStreamRequestArgsForCall = append(fake.removeTagsFromStreamRequestArgsForCall, struct { + arg1 *kinesis.RemoveTagsFromStreamInput + }{arg1}) + stub := fake.RemoveTagsFromStreamRequestStub + fakeReturns := fake.removeTagsFromStreamRequestReturns + fake.recordInvocation("RemoveTagsFromStreamRequest", []interface{}{arg1}) + fake.removeTagsFromStreamRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamRequestCallCount() int { + fake.removeTagsFromStreamRequestMutex.RLock() + defer fake.removeTagsFromStreamRequestMutex.RUnlock() + return len(fake.removeTagsFromStreamRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamRequestCalls(stub func(*kinesis.RemoveTagsFromStreamInput) (*request.Request, *kinesis.RemoveTagsFromStreamOutput)) { + fake.removeTagsFromStreamRequestMutex.Lock() + defer fake.removeTagsFromStreamRequestMutex.Unlock() + fake.RemoveTagsFromStreamRequestStub = stub +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamRequestArgsForCall(i int) *kinesis.RemoveTagsFromStreamInput { + fake.removeTagsFromStreamRequestMutex.RLock() + defer fake.removeTagsFromStreamRequestMutex.RUnlock() + argsForCall := fake.removeTagsFromStreamRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamRequestReturns(result1 *request.Request, result2 *kinesis.RemoveTagsFromStreamOutput) { + fake.removeTagsFromStreamRequestMutex.Lock() + defer fake.removeTagsFromStreamRequestMutex.Unlock() + fake.RemoveTagsFromStreamRequestStub = nil + fake.removeTagsFromStreamRequestReturns = struct { + result1 *request.Request + result2 *kinesis.RemoveTagsFromStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.RemoveTagsFromStreamOutput) { + fake.removeTagsFromStreamRequestMutex.Lock() + defer fake.removeTagsFromStreamRequestMutex.Unlock() + fake.RemoveTagsFromStreamRequestStub = nil + if fake.removeTagsFromStreamRequestReturnsOnCall == nil { + fake.removeTagsFromStreamRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.RemoveTagsFromStreamOutput + }) + } + fake.removeTagsFromStreamRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.RemoveTagsFromStreamOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamWithContext(arg1 context.Context, arg2 *kinesis.RemoveTagsFromStreamInput, arg3 ...request.Option) (*kinesis.RemoveTagsFromStreamOutput, error) { + fake.removeTagsFromStreamWithContextMutex.Lock() + ret, specificReturn := fake.removeTagsFromStreamWithContextReturnsOnCall[len(fake.removeTagsFromStreamWithContextArgsForCall)] + fake.removeTagsFromStreamWithContextArgsForCall = append(fake.removeTagsFromStreamWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.RemoveTagsFromStreamInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.RemoveTagsFromStreamWithContextStub + fakeReturns := fake.removeTagsFromStreamWithContextReturns + fake.recordInvocation("RemoveTagsFromStreamWithContext", []interface{}{arg1, arg2, arg3}) + fake.removeTagsFromStreamWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamWithContextCallCount() int { + fake.removeTagsFromStreamWithContextMutex.RLock() + defer fake.removeTagsFromStreamWithContextMutex.RUnlock() + return len(fake.removeTagsFromStreamWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamWithContextCalls(stub func(context.Context, *kinesis.RemoveTagsFromStreamInput, ...request.Option) (*kinesis.RemoveTagsFromStreamOutput, error)) { + fake.removeTagsFromStreamWithContextMutex.Lock() + defer fake.removeTagsFromStreamWithContextMutex.Unlock() + fake.RemoveTagsFromStreamWithContextStub = stub +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamWithContextArgsForCall(i int) (context.Context, *kinesis.RemoveTagsFromStreamInput, []request.Option) { + fake.removeTagsFromStreamWithContextMutex.RLock() + defer fake.removeTagsFromStreamWithContextMutex.RUnlock() + argsForCall := fake.removeTagsFromStreamWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamWithContextReturns(result1 *kinesis.RemoveTagsFromStreamOutput, result2 error) { + fake.removeTagsFromStreamWithContextMutex.Lock() + defer fake.removeTagsFromStreamWithContextMutex.Unlock() + fake.RemoveTagsFromStreamWithContextStub = nil + fake.removeTagsFromStreamWithContextReturns = struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) RemoveTagsFromStreamWithContextReturnsOnCall(i int, result1 *kinesis.RemoveTagsFromStreamOutput, result2 error) { + fake.removeTagsFromStreamWithContextMutex.Lock() + defer fake.removeTagsFromStreamWithContextMutex.Unlock() + fake.RemoveTagsFromStreamWithContextStub = nil + if fake.removeTagsFromStreamWithContextReturnsOnCall == nil { + fake.removeTagsFromStreamWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + }) + } + fake.removeTagsFromStreamWithContextReturnsOnCall[i] = struct { + result1 *kinesis.RemoveTagsFromStreamOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SplitShard(arg1 *kinesis.SplitShardInput) (*kinesis.SplitShardOutput, error) { + fake.splitShardMutex.Lock() + ret, specificReturn := fake.splitShardReturnsOnCall[len(fake.splitShardArgsForCall)] + fake.splitShardArgsForCall = append(fake.splitShardArgsForCall, struct { + arg1 *kinesis.SplitShardInput + }{arg1}) + stub := fake.SplitShardStub + fakeReturns := fake.splitShardReturns + fake.recordInvocation("SplitShard", []interface{}{arg1}) + fake.splitShardMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) SplitShardCallCount() int { + fake.splitShardMutex.RLock() + defer fake.splitShardMutex.RUnlock() + return len(fake.splitShardArgsForCall) +} + +func (fake *FakeKinesisAPI) SplitShardCalls(stub func(*kinesis.SplitShardInput) (*kinesis.SplitShardOutput, error)) { + fake.splitShardMutex.Lock() + defer fake.splitShardMutex.Unlock() + fake.SplitShardStub = stub +} + +func (fake *FakeKinesisAPI) SplitShardArgsForCall(i int) *kinesis.SplitShardInput { + fake.splitShardMutex.RLock() + defer fake.splitShardMutex.RUnlock() + argsForCall := fake.splitShardArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) SplitShardReturns(result1 *kinesis.SplitShardOutput, result2 error) { + fake.splitShardMutex.Lock() + defer fake.splitShardMutex.Unlock() + fake.SplitShardStub = nil + fake.splitShardReturns = struct { + result1 *kinesis.SplitShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SplitShardReturnsOnCall(i int, result1 *kinesis.SplitShardOutput, result2 error) { + fake.splitShardMutex.Lock() + defer fake.splitShardMutex.Unlock() + fake.SplitShardStub = nil + if fake.splitShardReturnsOnCall == nil { + fake.splitShardReturnsOnCall = make(map[int]struct { + result1 *kinesis.SplitShardOutput + result2 error + }) + } + fake.splitShardReturnsOnCall[i] = struct { + result1 *kinesis.SplitShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SplitShardRequest(arg1 *kinesis.SplitShardInput) (*request.Request, *kinesis.SplitShardOutput) { + fake.splitShardRequestMutex.Lock() + ret, specificReturn := fake.splitShardRequestReturnsOnCall[len(fake.splitShardRequestArgsForCall)] + fake.splitShardRequestArgsForCall = append(fake.splitShardRequestArgsForCall, struct { + arg1 *kinesis.SplitShardInput + }{arg1}) + stub := fake.SplitShardRequestStub + fakeReturns := fake.splitShardRequestReturns + fake.recordInvocation("SplitShardRequest", []interface{}{arg1}) + fake.splitShardRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) SplitShardRequestCallCount() int { + fake.splitShardRequestMutex.RLock() + defer fake.splitShardRequestMutex.RUnlock() + return len(fake.splitShardRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) SplitShardRequestCalls(stub func(*kinesis.SplitShardInput) (*request.Request, *kinesis.SplitShardOutput)) { + fake.splitShardRequestMutex.Lock() + defer fake.splitShardRequestMutex.Unlock() + fake.SplitShardRequestStub = stub +} + +func (fake *FakeKinesisAPI) SplitShardRequestArgsForCall(i int) *kinesis.SplitShardInput { + fake.splitShardRequestMutex.RLock() + defer fake.splitShardRequestMutex.RUnlock() + argsForCall := fake.splitShardRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) SplitShardRequestReturns(result1 *request.Request, result2 *kinesis.SplitShardOutput) { + fake.splitShardRequestMutex.Lock() + defer fake.splitShardRequestMutex.Unlock() + fake.SplitShardRequestStub = nil + fake.splitShardRequestReturns = struct { + result1 *request.Request + result2 *kinesis.SplitShardOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SplitShardRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.SplitShardOutput) { + fake.splitShardRequestMutex.Lock() + defer fake.splitShardRequestMutex.Unlock() + fake.SplitShardRequestStub = nil + if fake.splitShardRequestReturnsOnCall == nil { + fake.splitShardRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.SplitShardOutput + }) + } + fake.splitShardRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.SplitShardOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SplitShardWithContext(arg1 context.Context, arg2 *kinesis.SplitShardInput, arg3 ...request.Option) (*kinesis.SplitShardOutput, error) { + fake.splitShardWithContextMutex.Lock() + ret, specificReturn := fake.splitShardWithContextReturnsOnCall[len(fake.splitShardWithContextArgsForCall)] + fake.splitShardWithContextArgsForCall = append(fake.splitShardWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.SplitShardInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.SplitShardWithContextStub + fakeReturns := fake.splitShardWithContextReturns + fake.recordInvocation("SplitShardWithContext", []interface{}{arg1, arg2, arg3}) + fake.splitShardWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) SplitShardWithContextCallCount() int { + fake.splitShardWithContextMutex.RLock() + defer fake.splitShardWithContextMutex.RUnlock() + return len(fake.splitShardWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) SplitShardWithContextCalls(stub func(context.Context, *kinesis.SplitShardInput, ...request.Option) (*kinesis.SplitShardOutput, error)) { + fake.splitShardWithContextMutex.Lock() + defer fake.splitShardWithContextMutex.Unlock() + fake.SplitShardWithContextStub = stub +} + +func (fake *FakeKinesisAPI) SplitShardWithContextArgsForCall(i int) (context.Context, *kinesis.SplitShardInput, []request.Option) { + fake.splitShardWithContextMutex.RLock() + defer fake.splitShardWithContextMutex.RUnlock() + argsForCall := fake.splitShardWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) SplitShardWithContextReturns(result1 *kinesis.SplitShardOutput, result2 error) { + fake.splitShardWithContextMutex.Lock() + defer fake.splitShardWithContextMutex.Unlock() + fake.SplitShardWithContextStub = nil + fake.splitShardWithContextReturns = struct { + result1 *kinesis.SplitShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SplitShardWithContextReturnsOnCall(i int, result1 *kinesis.SplitShardOutput, result2 error) { + fake.splitShardWithContextMutex.Lock() + defer fake.splitShardWithContextMutex.Unlock() + fake.SplitShardWithContextStub = nil + if fake.splitShardWithContextReturnsOnCall == nil { + fake.splitShardWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.SplitShardOutput + result2 error + }) + } + fake.splitShardWithContextReturnsOnCall[i] = struct { + result1 *kinesis.SplitShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StartStreamEncryption(arg1 *kinesis.StartStreamEncryptionInput) (*kinesis.StartStreamEncryptionOutput, error) { + fake.startStreamEncryptionMutex.Lock() + ret, specificReturn := fake.startStreamEncryptionReturnsOnCall[len(fake.startStreamEncryptionArgsForCall)] + fake.startStreamEncryptionArgsForCall = append(fake.startStreamEncryptionArgsForCall, struct { + arg1 *kinesis.StartStreamEncryptionInput + }{arg1}) + stub := fake.StartStreamEncryptionStub + fakeReturns := fake.startStreamEncryptionReturns + fake.recordInvocation("StartStreamEncryption", []interface{}{arg1}) + fake.startStreamEncryptionMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionCallCount() int { + fake.startStreamEncryptionMutex.RLock() + defer fake.startStreamEncryptionMutex.RUnlock() + return len(fake.startStreamEncryptionArgsForCall) +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionCalls(stub func(*kinesis.StartStreamEncryptionInput) (*kinesis.StartStreamEncryptionOutput, error)) { + fake.startStreamEncryptionMutex.Lock() + defer fake.startStreamEncryptionMutex.Unlock() + fake.StartStreamEncryptionStub = stub +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionArgsForCall(i int) *kinesis.StartStreamEncryptionInput { + fake.startStreamEncryptionMutex.RLock() + defer fake.startStreamEncryptionMutex.RUnlock() + argsForCall := fake.startStreamEncryptionArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionReturns(result1 *kinesis.StartStreamEncryptionOutput, result2 error) { + fake.startStreamEncryptionMutex.Lock() + defer fake.startStreamEncryptionMutex.Unlock() + fake.StartStreamEncryptionStub = nil + fake.startStreamEncryptionReturns = struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionReturnsOnCall(i int, result1 *kinesis.StartStreamEncryptionOutput, result2 error) { + fake.startStreamEncryptionMutex.Lock() + defer fake.startStreamEncryptionMutex.Unlock() + fake.StartStreamEncryptionStub = nil + if fake.startStreamEncryptionReturnsOnCall == nil { + fake.startStreamEncryptionReturnsOnCall = make(map[int]struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + }) + } + fake.startStreamEncryptionReturnsOnCall[i] = struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionRequest(arg1 *kinesis.StartStreamEncryptionInput) (*request.Request, *kinesis.StartStreamEncryptionOutput) { + fake.startStreamEncryptionRequestMutex.Lock() + ret, specificReturn := fake.startStreamEncryptionRequestReturnsOnCall[len(fake.startStreamEncryptionRequestArgsForCall)] + fake.startStreamEncryptionRequestArgsForCall = append(fake.startStreamEncryptionRequestArgsForCall, struct { + arg1 *kinesis.StartStreamEncryptionInput + }{arg1}) + stub := fake.StartStreamEncryptionRequestStub + fakeReturns := fake.startStreamEncryptionRequestReturns + fake.recordInvocation("StartStreamEncryptionRequest", []interface{}{arg1}) + fake.startStreamEncryptionRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionRequestCallCount() int { + fake.startStreamEncryptionRequestMutex.RLock() + defer fake.startStreamEncryptionRequestMutex.RUnlock() + return len(fake.startStreamEncryptionRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionRequestCalls(stub func(*kinesis.StartStreamEncryptionInput) (*request.Request, *kinesis.StartStreamEncryptionOutput)) { + fake.startStreamEncryptionRequestMutex.Lock() + defer fake.startStreamEncryptionRequestMutex.Unlock() + fake.StartStreamEncryptionRequestStub = stub +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionRequestArgsForCall(i int) *kinesis.StartStreamEncryptionInput { + fake.startStreamEncryptionRequestMutex.RLock() + defer fake.startStreamEncryptionRequestMutex.RUnlock() + argsForCall := fake.startStreamEncryptionRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionRequestReturns(result1 *request.Request, result2 *kinesis.StartStreamEncryptionOutput) { + fake.startStreamEncryptionRequestMutex.Lock() + defer fake.startStreamEncryptionRequestMutex.Unlock() + fake.StartStreamEncryptionRequestStub = nil + fake.startStreamEncryptionRequestReturns = struct { + result1 *request.Request + result2 *kinesis.StartStreamEncryptionOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.StartStreamEncryptionOutput) { + fake.startStreamEncryptionRequestMutex.Lock() + defer fake.startStreamEncryptionRequestMutex.Unlock() + fake.StartStreamEncryptionRequestStub = nil + if fake.startStreamEncryptionRequestReturnsOnCall == nil { + fake.startStreamEncryptionRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.StartStreamEncryptionOutput + }) + } + fake.startStreamEncryptionRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.StartStreamEncryptionOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionWithContext(arg1 context.Context, arg2 *kinesis.StartStreamEncryptionInput, arg3 ...request.Option) (*kinesis.StartStreamEncryptionOutput, error) { + fake.startStreamEncryptionWithContextMutex.Lock() + ret, specificReturn := fake.startStreamEncryptionWithContextReturnsOnCall[len(fake.startStreamEncryptionWithContextArgsForCall)] + fake.startStreamEncryptionWithContextArgsForCall = append(fake.startStreamEncryptionWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.StartStreamEncryptionInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.StartStreamEncryptionWithContextStub + fakeReturns := fake.startStreamEncryptionWithContextReturns + fake.recordInvocation("StartStreamEncryptionWithContext", []interface{}{arg1, arg2, arg3}) + fake.startStreamEncryptionWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionWithContextCallCount() int { + fake.startStreamEncryptionWithContextMutex.RLock() + defer fake.startStreamEncryptionWithContextMutex.RUnlock() + return len(fake.startStreamEncryptionWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionWithContextCalls(stub func(context.Context, *kinesis.StartStreamEncryptionInput, ...request.Option) (*kinesis.StartStreamEncryptionOutput, error)) { + fake.startStreamEncryptionWithContextMutex.Lock() + defer fake.startStreamEncryptionWithContextMutex.Unlock() + fake.StartStreamEncryptionWithContextStub = stub +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionWithContextArgsForCall(i int) (context.Context, *kinesis.StartStreamEncryptionInput, []request.Option) { + fake.startStreamEncryptionWithContextMutex.RLock() + defer fake.startStreamEncryptionWithContextMutex.RUnlock() + argsForCall := fake.startStreamEncryptionWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionWithContextReturns(result1 *kinesis.StartStreamEncryptionOutput, result2 error) { + fake.startStreamEncryptionWithContextMutex.Lock() + defer fake.startStreamEncryptionWithContextMutex.Unlock() + fake.StartStreamEncryptionWithContextStub = nil + fake.startStreamEncryptionWithContextReturns = struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StartStreamEncryptionWithContextReturnsOnCall(i int, result1 *kinesis.StartStreamEncryptionOutput, result2 error) { + fake.startStreamEncryptionWithContextMutex.Lock() + defer fake.startStreamEncryptionWithContextMutex.Unlock() + fake.StartStreamEncryptionWithContextStub = nil + if fake.startStreamEncryptionWithContextReturnsOnCall == nil { + fake.startStreamEncryptionWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + }) + } + fake.startStreamEncryptionWithContextReturnsOnCall[i] = struct { + result1 *kinesis.StartStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StopStreamEncryption(arg1 *kinesis.StopStreamEncryptionInput) (*kinesis.StopStreamEncryptionOutput, error) { + fake.stopStreamEncryptionMutex.Lock() + ret, specificReturn := fake.stopStreamEncryptionReturnsOnCall[len(fake.stopStreamEncryptionArgsForCall)] + fake.stopStreamEncryptionArgsForCall = append(fake.stopStreamEncryptionArgsForCall, struct { + arg1 *kinesis.StopStreamEncryptionInput + }{arg1}) + stub := fake.StopStreamEncryptionStub + fakeReturns := fake.stopStreamEncryptionReturns + fake.recordInvocation("StopStreamEncryption", []interface{}{arg1}) + fake.stopStreamEncryptionMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionCallCount() int { + fake.stopStreamEncryptionMutex.RLock() + defer fake.stopStreamEncryptionMutex.RUnlock() + return len(fake.stopStreamEncryptionArgsForCall) +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionCalls(stub func(*kinesis.StopStreamEncryptionInput) (*kinesis.StopStreamEncryptionOutput, error)) { + fake.stopStreamEncryptionMutex.Lock() + defer fake.stopStreamEncryptionMutex.Unlock() + fake.StopStreamEncryptionStub = stub +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionArgsForCall(i int) *kinesis.StopStreamEncryptionInput { + fake.stopStreamEncryptionMutex.RLock() + defer fake.stopStreamEncryptionMutex.RUnlock() + argsForCall := fake.stopStreamEncryptionArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionReturns(result1 *kinesis.StopStreamEncryptionOutput, result2 error) { + fake.stopStreamEncryptionMutex.Lock() + defer fake.stopStreamEncryptionMutex.Unlock() + fake.StopStreamEncryptionStub = nil + fake.stopStreamEncryptionReturns = struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionReturnsOnCall(i int, result1 *kinesis.StopStreamEncryptionOutput, result2 error) { + fake.stopStreamEncryptionMutex.Lock() + defer fake.stopStreamEncryptionMutex.Unlock() + fake.StopStreamEncryptionStub = nil + if fake.stopStreamEncryptionReturnsOnCall == nil { + fake.stopStreamEncryptionReturnsOnCall = make(map[int]struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + }) + } + fake.stopStreamEncryptionReturnsOnCall[i] = struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionRequest(arg1 *kinesis.StopStreamEncryptionInput) (*request.Request, *kinesis.StopStreamEncryptionOutput) { + fake.stopStreamEncryptionRequestMutex.Lock() + ret, specificReturn := fake.stopStreamEncryptionRequestReturnsOnCall[len(fake.stopStreamEncryptionRequestArgsForCall)] + fake.stopStreamEncryptionRequestArgsForCall = append(fake.stopStreamEncryptionRequestArgsForCall, struct { + arg1 *kinesis.StopStreamEncryptionInput + }{arg1}) + stub := fake.StopStreamEncryptionRequestStub + fakeReturns := fake.stopStreamEncryptionRequestReturns + fake.recordInvocation("StopStreamEncryptionRequest", []interface{}{arg1}) + fake.stopStreamEncryptionRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionRequestCallCount() int { + fake.stopStreamEncryptionRequestMutex.RLock() + defer fake.stopStreamEncryptionRequestMutex.RUnlock() + return len(fake.stopStreamEncryptionRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionRequestCalls(stub func(*kinesis.StopStreamEncryptionInput) (*request.Request, *kinesis.StopStreamEncryptionOutput)) { + fake.stopStreamEncryptionRequestMutex.Lock() + defer fake.stopStreamEncryptionRequestMutex.Unlock() + fake.StopStreamEncryptionRequestStub = stub +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionRequestArgsForCall(i int) *kinesis.StopStreamEncryptionInput { + fake.stopStreamEncryptionRequestMutex.RLock() + defer fake.stopStreamEncryptionRequestMutex.RUnlock() + argsForCall := fake.stopStreamEncryptionRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionRequestReturns(result1 *request.Request, result2 *kinesis.StopStreamEncryptionOutput) { + fake.stopStreamEncryptionRequestMutex.Lock() + defer fake.stopStreamEncryptionRequestMutex.Unlock() + fake.StopStreamEncryptionRequestStub = nil + fake.stopStreamEncryptionRequestReturns = struct { + result1 *request.Request + result2 *kinesis.StopStreamEncryptionOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.StopStreamEncryptionOutput) { + fake.stopStreamEncryptionRequestMutex.Lock() + defer fake.stopStreamEncryptionRequestMutex.Unlock() + fake.StopStreamEncryptionRequestStub = nil + if fake.stopStreamEncryptionRequestReturnsOnCall == nil { + fake.stopStreamEncryptionRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.StopStreamEncryptionOutput + }) + } + fake.stopStreamEncryptionRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.StopStreamEncryptionOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionWithContext(arg1 context.Context, arg2 *kinesis.StopStreamEncryptionInput, arg3 ...request.Option) (*kinesis.StopStreamEncryptionOutput, error) { + fake.stopStreamEncryptionWithContextMutex.Lock() + ret, specificReturn := fake.stopStreamEncryptionWithContextReturnsOnCall[len(fake.stopStreamEncryptionWithContextArgsForCall)] + fake.stopStreamEncryptionWithContextArgsForCall = append(fake.stopStreamEncryptionWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.StopStreamEncryptionInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.StopStreamEncryptionWithContextStub + fakeReturns := fake.stopStreamEncryptionWithContextReturns + fake.recordInvocation("StopStreamEncryptionWithContext", []interface{}{arg1, arg2, arg3}) + fake.stopStreamEncryptionWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionWithContextCallCount() int { + fake.stopStreamEncryptionWithContextMutex.RLock() + defer fake.stopStreamEncryptionWithContextMutex.RUnlock() + return len(fake.stopStreamEncryptionWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionWithContextCalls(stub func(context.Context, *kinesis.StopStreamEncryptionInput, ...request.Option) (*kinesis.StopStreamEncryptionOutput, error)) { + fake.stopStreamEncryptionWithContextMutex.Lock() + defer fake.stopStreamEncryptionWithContextMutex.Unlock() + fake.StopStreamEncryptionWithContextStub = stub +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionWithContextArgsForCall(i int) (context.Context, *kinesis.StopStreamEncryptionInput, []request.Option) { + fake.stopStreamEncryptionWithContextMutex.RLock() + defer fake.stopStreamEncryptionWithContextMutex.RUnlock() + argsForCall := fake.stopStreamEncryptionWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionWithContextReturns(result1 *kinesis.StopStreamEncryptionOutput, result2 error) { + fake.stopStreamEncryptionWithContextMutex.Lock() + defer fake.stopStreamEncryptionWithContextMutex.Unlock() + fake.StopStreamEncryptionWithContextStub = nil + fake.stopStreamEncryptionWithContextReturns = struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) StopStreamEncryptionWithContextReturnsOnCall(i int, result1 *kinesis.StopStreamEncryptionOutput, result2 error) { + fake.stopStreamEncryptionWithContextMutex.Lock() + defer fake.stopStreamEncryptionWithContextMutex.Unlock() + fake.StopStreamEncryptionWithContextStub = nil + if fake.stopStreamEncryptionWithContextReturnsOnCall == nil { + fake.stopStreamEncryptionWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + }) + } + fake.stopStreamEncryptionWithContextReturnsOnCall[i] = struct { + result1 *kinesis.StopStreamEncryptionOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SubscribeToShard(arg1 *kinesis.SubscribeToShardInput) (*kinesis.SubscribeToShardOutput, error) { + fake.subscribeToShardMutex.Lock() + ret, specificReturn := fake.subscribeToShardReturnsOnCall[len(fake.subscribeToShardArgsForCall)] + fake.subscribeToShardArgsForCall = append(fake.subscribeToShardArgsForCall, struct { + arg1 *kinesis.SubscribeToShardInput + }{arg1}) + stub := fake.SubscribeToShardStub + fakeReturns := fake.subscribeToShardReturns + fake.recordInvocation("SubscribeToShard", []interface{}{arg1}) + fake.subscribeToShardMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) SubscribeToShardCallCount() int { + fake.subscribeToShardMutex.RLock() + defer fake.subscribeToShardMutex.RUnlock() + return len(fake.subscribeToShardArgsForCall) +} + +func (fake *FakeKinesisAPI) SubscribeToShardCalls(stub func(*kinesis.SubscribeToShardInput) (*kinesis.SubscribeToShardOutput, error)) { + fake.subscribeToShardMutex.Lock() + defer fake.subscribeToShardMutex.Unlock() + fake.SubscribeToShardStub = stub +} + +func (fake *FakeKinesisAPI) SubscribeToShardArgsForCall(i int) *kinesis.SubscribeToShardInput { + fake.subscribeToShardMutex.RLock() + defer fake.subscribeToShardMutex.RUnlock() + argsForCall := fake.subscribeToShardArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) SubscribeToShardReturns(result1 *kinesis.SubscribeToShardOutput, result2 error) { + fake.subscribeToShardMutex.Lock() + defer fake.subscribeToShardMutex.Unlock() + fake.SubscribeToShardStub = nil + fake.subscribeToShardReturns = struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SubscribeToShardReturnsOnCall(i int, result1 *kinesis.SubscribeToShardOutput, result2 error) { + fake.subscribeToShardMutex.Lock() + defer fake.subscribeToShardMutex.Unlock() + fake.SubscribeToShardStub = nil + if fake.subscribeToShardReturnsOnCall == nil { + fake.subscribeToShardReturnsOnCall = make(map[int]struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + }) + } + fake.subscribeToShardReturnsOnCall[i] = struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SubscribeToShardRequest(arg1 *kinesis.SubscribeToShardInput) (*request.Request, *kinesis.SubscribeToShardOutput) { + fake.subscribeToShardRequestMutex.Lock() + ret, specificReturn := fake.subscribeToShardRequestReturnsOnCall[len(fake.subscribeToShardRequestArgsForCall)] + fake.subscribeToShardRequestArgsForCall = append(fake.subscribeToShardRequestArgsForCall, struct { + arg1 *kinesis.SubscribeToShardInput + }{arg1}) + stub := fake.SubscribeToShardRequestStub + fakeReturns := fake.subscribeToShardRequestReturns + fake.recordInvocation("SubscribeToShardRequest", []interface{}{arg1}) + fake.subscribeToShardRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) SubscribeToShardRequestCallCount() int { + fake.subscribeToShardRequestMutex.RLock() + defer fake.subscribeToShardRequestMutex.RUnlock() + return len(fake.subscribeToShardRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) SubscribeToShardRequestCalls(stub func(*kinesis.SubscribeToShardInput) (*request.Request, *kinesis.SubscribeToShardOutput)) { + fake.subscribeToShardRequestMutex.Lock() + defer fake.subscribeToShardRequestMutex.Unlock() + fake.SubscribeToShardRequestStub = stub +} + +func (fake *FakeKinesisAPI) SubscribeToShardRequestArgsForCall(i int) *kinesis.SubscribeToShardInput { + fake.subscribeToShardRequestMutex.RLock() + defer fake.subscribeToShardRequestMutex.RUnlock() + argsForCall := fake.subscribeToShardRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) SubscribeToShardRequestReturns(result1 *request.Request, result2 *kinesis.SubscribeToShardOutput) { + fake.subscribeToShardRequestMutex.Lock() + defer fake.subscribeToShardRequestMutex.Unlock() + fake.SubscribeToShardRequestStub = nil + fake.subscribeToShardRequestReturns = struct { + result1 *request.Request + result2 *kinesis.SubscribeToShardOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SubscribeToShardRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.SubscribeToShardOutput) { + fake.subscribeToShardRequestMutex.Lock() + defer fake.subscribeToShardRequestMutex.Unlock() + fake.SubscribeToShardRequestStub = nil + if fake.subscribeToShardRequestReturnsOnCall == nil { + fake.subscribeToShardRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.SubscribeToShardOutput + }) + } + fake.subscribeToShardRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.SubscribeToShardOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SubscribeToShardWithContext(arg1 context.Context, arg2 *kinesis.SubscribeToShardInput, arg3 ...request.Option) (*kinesis.SubscribeToShardOutput, error) { + fake.subscribeToShardWithContextMutex.Lock() + ret, specificReturn := fake.subscribeToShardWithContextReturnsOnCall[len(fake.subscribeToShardWithContextArgsForCall)] + fake.subscribeToShardWithContextArgsForCall = append(fake.subscribeToShardWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.SubscribeToShardInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.SubscribeToShardWithContextStub + fakeReturns := fake.subscribeToShardWithContextReturns + fake.recordInvocation("SubscribeToShardWithContext", []interface{}{arg1, arg2, arg3}) + fake.subscribeToShardWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) SubscribeToShardWithContextCallCount() int { + fake.subscribeToShardWithContextMutex.RLock() + defer fake.subscribeToShardWithContextMutex.RUnlock() + return len(fake.subscribeToShardWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) SubscribeToShardWithContextCalls(stub func(context.Context, *kinesis.SubscribeToShardInput, ...request.Option) (*kinesis.SubscribeToShardOutput, error)) { + fake.subscribeToShardWithContextMutex.Lock() + defer fake.subscribeToShardWithContextMutex.Unlock() + fake.SubscribeToShardWithContextStub = stub +} + +func (fake *FakeKinesisAPI) SubscribeToShardWithContextArgsForCall(i int) (context.Context, *kinesis.SubscribeToShardInput, []request.Option) { + fake.subscribeToShardWithContextMutex.RLock() + defer fake.subscribeToShardWithContextMutex.RUnlock() + argsForCall := fake.subscribeToShardWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) SubscribeToShardWithContextReturns(result1 *kinesis.SubscribeToShardOutput, result2 error) { + fake.subscribeToShardWithContextMutex.Lock() + defer fake.subscribeToShardWithContextMutex.Unlock() + fake.SubscribeToShardWithContextStub = nil + fake.subscribeToShardWithContextReturns = struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) SubscribeToShardWithContextReturnsOnCall(i int, result1 *kinesis.SubscribeToShardOutput, result2 error) { + fake.subscribeToShardWithContextMutex.Lock() + defer fake.subscribeToShardWithContextMutex.Unlock() + fake.SubscribeToShardWithContextStub = nil + if fake.subscribeToShardWithContextReturnsOnCall == nil { + fake.subscribeToShardWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + }) + } + fake.subscribeToShardWithContextReturnsOnCall[i] = struct { + result1 *kinesis.SubscribeToShardOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) UpdateShardCount(arg1 *kinesis.UpdateShardCountInput) (*kinesis.UpdateShardCountOutput, error) { + fake.updateShardCountMutex.Lock() + ret, specificReturn := fake.updateShardCountReturnsOnCall[len(fake.updateShardCountArgsForCall)] + fake.updateShardCountArgsForCall = append(fake.updateShardCountArgsForCall, struct { + arg1 *kinesis.UpdateShardCountInput + }{arg1}) + stub := fake.UpdateShardCountStub + fakeReturns := fake.updateShardCountReturns + fake.recordInvocation("UpdateShardCount", []interface{}{arg1}) + fake.updateShardCountMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) UpdateShardCountCallCount() int { + fake.updateShardCountMutex.RLock() + defer fake.updateShardCountMutex.RUnlock() + return len(fake.updateShardCountArgsForCall) +} + +func (fake *FakeKinesisAPI) UpdateShardCountCalls(stub func(*kinesis.UpdateShardCountInput) (*kinesis.UpdateShardCountOutput, error)) { + fake.updateShardCountMutex.Lock() + defer fake.updateShardCountMutex.Unlock() + fake.UpdateShardCountStub = stub +} + +func (fake *FakeKinesisAPI) UpdateShardCountArgsForCall(i int) *kinesis.UpdateShardCountInput { + fake.updateShardCountMutex.RLock() + defer fake.updateShardCountMutex.RUnlock() + argsForCall := fake.updateShardCountArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) UpdateShardCountReturns(result1 *kinesis.UpdateShardCountOutput, result2 error) { + fake.updateShardCountMutex.Lock() + defer fake.updateShardCountMutex.Unlock() + fake.UpdateShardCountStub = nil + fake.updateShardCountReturns = struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) UpdateShardCountReturnsOnCall(i int, result1 *kinesis.UpdateShardCountOutput, result2 error) { + fake.updateShardCountMutex.Lock() + defer fake.updateShardCountMutex.Unlock() + fake.UpdateShardCountStub = nil + if fake.updateShardCountReturnsOnCall == nil { + fake.updateShardCountReturnsOnCall = make(map[int]struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + }) + } + fake.updateShardCountReturnsOnCall[i] = struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) UpdateShardCountRequest(arg1 *kinesis.UpdateShardCountInput) (*request.Request, *kinesis.UpdateShardCountOutput) { + fake.updateShardCountRequestMutex.Lock() + ret, specificReturn := fake.updateShardCountRequestReturnsOnCall[len(fake.updateShardCountRequestArgsForCall)] + fake.updateShardCountRequestArgsForCall = append(fake.updateShardCountRequestArgsForCall, struct { + arg1 *kinesis.UpdateShardCountInput + }{arg1}) + stub := fake.UpdateShardCountRequestStub + fakeReturns := fake.updateShardCountRequestReturns + fake.recordInvocation("UpdateShardCountRequest", []interface{}{arg1}) + fake.updateShardCountRequestMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) UpdateShardCountRequestCallCount() int { + fake.updateShardCountRequestMutex.RLock() + defer fake.updateShardCountRequestMutex.RUnlock() + return len(fake.updateShardCountRequestArgsForCall) +} + +func (fake *FakeKinesisAPI) UpdateShardCountRequestCalls(stub func(*kinesis.UpdateShardCountInput) (*request.Request, *kinesis.UpdateShardCountOutput)) { + fake.updateShardCountRequestMutex.Lock() + defer fake.updateShardCountRequestMutex.Unlock() + fake.UpdateShardCountRequestStub = stub +} + +func (fake *FakeKinesisAPI) UpdateShardCountRequestArgsForCall(i int) *kinesis.UpdateShardCountInput { + fake.updateShardCountRequestMutex.RLock() + defer fake.updateShardCountRequestMutex.RUnlock() + argsForCall := fake.updateShardCountRequestArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) UpdateShardCountRequestReturns(result1 *request.Request, result2 *kinesis.UpdateShardCountOutput) { + fake.updateShardCountRequestMutex.Lock() + defer fake.updateShardCountRequestMutex.Unlock() + fake.UpdateShardCountRequestStub = nil + fake.updateShardCountRequestReturns = struct { + result1 *request.Request + result2 *kinesis.UpdateShardCountOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) UpdateShardCountRequestReturnsOnCall(i int, result1 *request.Request, result2 *kinesis.UpdateShardCountOutput) { + fake.updateShardCountRequestMutex.Lock() + defer fake.updateShardCountRequestMutex.Unlock() + fake.UpdateShardCountRequestStub = nil + if fake.updateShardCountRequestReturnsOnCall == nil { + fake.updateShardCountRequestReturnsOnCall = make(map[int]struct { + result1 *request.Request + result2 *kinesis.UpdateShardCountOutput + }) + } + fake.updateShardCountRequestReturnsOnCall[i] = struct { + result1 *request.Request + result2 *kinesis.UpdateShardCountOutput + }{result1, result2} +} + +func (fake *FakeKinesisAPI) UpdateShardCountWithContext(arg1 context.Context, arg2 *kinesis.UpdateShardCountInput, arg3 ...request.Option) (*kinesis.UpdateShardCountOutput, error) { + fake.updateShardCountWithContextMutex.Lock() + ret, specificReturn := fake.updateShardCountWithContextReturnsOnCall[len(fake.updateShardCountWithContextArgsForCall)] + fake.updateShardCountWithContextArgsForCall = append(fake.updateShardCountWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.UpdateShardCountInput + arg3 []request.Option + }{arg1, arg2, arg3}) + stub := fake.UpdateShardCountWithContextStub + fakeReturns := fake.updateShardCountWithContextReturns + fake.recordInvocation("UpdateShardCountWithContext", []interface{}{arg1, arg2, arg3}) + fake.updateShardCountWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeKinesisAPI) UpdateShardCountWithContextCallCount() int { + fake.updateShardCountWithContextMutex.RLock() + defer fake.updateShardCountWithContextMutex.RUnlock() + return len(fake.updateShardCountWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) UpdateShardCountWithContextCalls(stub func(context.Context, *kinesis.UpdateShardCountInput, ...request.Option) (*kinesis.UpdateShardCountOutput, error)) { + fake.updateShardCountWithContextMutex.Lock() + defer fake.updateShardCountWithContextMutex.Unlock() + fake.UpdateShardCountWithContextStub = stub +} + +func (fake *FakeKinesisAPI) UpdateShardCountWithContextArgsForCall(i int) (context.Context, *kinesis.UpdateShardCountInput, []request.Option) { + fake.updateShardCountWithContextMutex.RLock() + defer fake.updateShardCountWithContextMutex.RUnlock() + argsForCall := fake.updateShardCountWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) UpdateShardCountWithContextReturns(result1 *kinesis.UpdateShardCountOutput, result2 error) { + fake.updateShardCountWithContextMutex.Lock() + defer fake.updateShardCountWithContextMutex.Unlock() + fake.UpdateShardCountWithContextStub = nil + fake.updateShardCountWithContextReturns = struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) UpdateShardCountWithContextReturnsOnCall(i int, result1 *kinesis.UpdateShardCountOutput, result2 error) { + fake.updateShardCountWithContextMutex.Lock() + defer fake.updateShardCountWithContextMutex.Unlock() + fake.UpdateShardCountWithContextStub = nil + if fake.updateShardCountWithContextReturnsOnCall == nil { + fake.updateShardCountWithContextReturnsOnCall = make(map[int]struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + }) + } + fake.updateShardCountWithContextReturnsOnCall[i] = struct { + result1 *kinesis.UpdateShardCountOutput + result2 error + }{result1, result2} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExists(arg1 *kinesis.DescribeStreamInput) error { + fake.waitUntilStreamExistsMutex.Lock() + ret, specificReturn := fake.waitUntilStreamExistsReturnsOnCall[len(fake.waitUntilStreamExistsArgsForCall)] + fake.waitUntilStreamExistsArgsForCall = append(fake.waitUntilStreamExistsArgsForCall, struct { + arg1 *kinesis.DescribeStreamInput + }{arg1}) + stub := fake.WaitUntilStreamExistsStub + fakeReturns := fake.waitUntilStreamExistsReturns + fake.recordInvocation("WaitUntilStreamExists", []interface{}{arg1}) + fake.waitUntilStreamExistsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsCallCount() int { + fake.waitUntilStreamExistsMutex.RLock() + defer fake.waitUntilStreamExistsMutex.RUnlock() + return len(fake.waitUntilStreamExistsArgsForCall) +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsCalls(stub func(*kinesis.DescribeStreamInput) error) { + fake.waitUntilStreamExistsMutex.Lock() + defer fake.waitUntilStreamExistsMutex.Unlock() + fake.WaitUntilStreamExistsStub = stub +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsArgsForCall(i int) *kinesis.DescribeStreamInput { + fake.waitUntilStreamExistsMutex.RLock() + defer fake.waitUntilStreamExistsMutex.RUnlock() + argsForCall := fake.waitUntilStreamExistsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsReturns(result1 error) { + fake.waitUntilStreamExistsMutex.Lock() + defer fake.waitUntilStreamExistsMutex.Unlock() + fake.WaitUntilStreamExistsStub = nil + fake.waitUntilStreamExistsReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsReturnsOnCall(i int, result1 error) { + fake.waitUntilStreamExistsMutex.Lock() + defer fake.waitUntilStreamExistsMutex.Unlock() + fake.WaitUntilStreamExistsStub = nil + if fake.waitUntilStreamExistsReturnsOnCall == nil { + fake.waitUntilStreamExistsReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.waitUntilStreamExistsReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsWithContext(arg1 context.Context, arg2 *kinesis.DescribeStreamInput, arg3 ...request.WaiterOption) error { + fake.waitUntilStreamExistsWithContextMutex.Lock() + ret, specificReturn := fake.waitUntilStreamExistsWithContextReturnsOnCall[len(fake.waitUntilStreamExistsWithContextArgsForCall)] + fake.waitUntilStreamExistsWithContextArgsForCall = append(fake.waitUntilStreamExistsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 []request.WaiterOption + }{arg1, arg2, arg3}) + stub := fake.WaitUntilStreamExistsWithContextStub + fakeReturns := fake.waitUntilStreamExistsWithContextReturns + fake.recordInvocation("WaitUntilStreamExistsWithContext", []interface{}{arg1, arg2, arg3}) + fake.waitUntilStreamExistsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsWithContextCallCount() int { + fake.waitUntilStreamExistsWithContextMutex.RLock() + defer fake.waitUntilStreamExistsWithContextMutex.RUnlock() + return len(fake.waitUntilStreamExistsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsWithContextCalls(stub func(context.Context, *kinesis.DescribeStreamInput, ...request.WaiterOption) error) { + fake.waitUntilStreamExistsWithContextMutex.Lock() + defer fake.waitUntilStreamExistsWithContextMutex.Unlock() + fake.WaitUntilStreamExistsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsWithContextArgsForCall(i int) (context.Context, *kinesis.DescribeStreamInput, []request.WaiterOption) { + fake.waitUntilStreamExistsWithContextMutex.RLock() + defer fake.waitUntilStreamExistsWithContextMutex.RUnlock() + argsForCall := fake.waitUntilStreamExistsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsWithContextReturns(result1 error) { + fake.waitUntilStreamExistsWithContextMutex.Lock() + defer fake.waitUntilStreamExistsWithContextMutex.Unlock() + fake.WaitUntilStreamExistsWithContextStub = nil + fake.waitUntilStreamExistsWithContextReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamExistsWithContextReturnsOnCall(i int, result1 error) { + fake.waitUntilStreamExistsWithContextMutex.Lock() + defer fake.waitUntilStreamExistsWithContextMutex.Unlock() + fake.WaitUntilStreamExistsWithContextStub = nil + if fake.waitUntilStreamExistsWithContextReturnsOnCall == nil { + fake.waitUntilStreamExistsWithContextReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.waitUntilStreamExistsWithContextReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExists(arg1 *kinesis.DescribeStreamInput) error { + fake.waitUntilStreamNotExistsMutex.Lock() + ret, specificReturn := fake.waitUntilStreamNotExistsReturnsOnCall[len(fake.waitUntilStreamNotExistsArgsForCall)] + fake.waitUntilStreamNotExistsArgsForCall = append(fake.waitUntilStreamNotExistsArgsForCall, struct { + arg1 *kinesis.DescribeStreamInput + }{arg1}) + stub := fake.WaitUntilStreamNotExistsStub + fakeReturns := fake.waitUntilStreamNotExistsReturns + fake.recordInvocation("WaitUntilStreamNotExists", []interface{}{arg1}) + fake.waitUntilStreamNotExistsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsCallCount() int { + fake.waitUntilStreamNotExistsMutex.RLock() + defer fake.waitUntilStreamNotExistsMutex.RUnlock() + return len(fake.waitUntilStreamNotExistsArgsForCall) +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsCalls(stub func(*kinesis.DescribeStreamInput) error) { + fake.waitUntilStreamNotExistsMutex.Lock() + defer fake.waitUntilStreamNotExistsMutex.Unlock() + fake.WaitUntilStreamNotExistsStub = stub +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsArgsForCall(i int) *kinesis.DescribeStreamInput { + fake.waitUntilStreamNotExistsMutex.RLock() + defer fake.waitUntilStreamNotExistsMutex.RUnlock() + argsForCall := fake.waitUntilStreamNotExistsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsReturns(result1 error) { + fake.waitUntilStreamNotExistsMutex.Lock() + defer fake.waitUntilStreamNotExistsMutex.Unlock() + fake.WaitUntilStreamNotExistsStub = nil + fake.waitUntilStreamNotExistsReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsReturnsOnCall(i int, result1 error) { + fake.waitUntilStreamNotExistsMutex.Lock() + defer fake.waitUntilStreamNotExistsMutex.Unlock() + fake.WaitUntilStreamNotExistsStub = nil + if fake.waitUntilStreamNotExistsReturnsOnCall == nil { + fake.waitUntilStreamNotExistsReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.waitUntilStreamNotExistsReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsWithContext(arg1 context.Context, arg2 *kinesis.DescribeStreamInput, arg3 ...request.WaiterOption) error { + fake.waitUntilStreamNotExistsWithContextMutex.Lock() + ret, specificReturn := fake.waitUntilStreamNotExistsWithContextReturnsOnCall[len(fake.waitUntilStreamNotExistsWithContextArgsForCall)] + fake.waitUntilStreamNotExistsWithContextArgsForCall = append(fake.waitUntilStreamNotExistsWithContextArgsForCall, struct { + arg1 context.Context + arg2 *kinesis.DescribeStreamInput + arg3 []request.WaiterOption + }{arg1, arg2, arg3}) + stub := fake.WaitUntilStreamNotExistsWithContextStub + fakeReturns := fake.waitUntilStreamNotExistsWithContextReturns + fake.recordInvocation("WaitUntilStreamNotExistsWithContext", []interface{}{arg1, arg2, arg3}) + fake.waitUntilStreamNotExistsWithContextMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsWithContextCallCount() int { + fake.waitUntilStreamNotExistsWithContextMutex.RLock() + defer fake.waitUntilStreamNotExistsWithContextMutex.RUnlock() + return len(fake.waitUntilStreamNotExistsWithContextArgsForCall) +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsWithContextCalls(stub func(context.Context, *kinesis.DescribeStreamInput, ...request.WaiterOption) error) { + fake.waitUntilStreamNotExistsWithContextMutex.Lock() + defer fake.waitUntilStreamNotExistsWithContextMutex.Unlock() + fake.WaitUntilStreamNotExistsWithContextStub = stub +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsWithContextArgsForCall(i int) (context.Context, *kinesis.DescribeStreamInput, []request.WaiterOption) { + fake.waitUntilStreamNotExistsWithContextMutex.RLock() + defer fake.waitUntilStreamNotExistsWithContextMutex.RUnlock() + argsForCall := fake.waitUntilStreamNotExistsWithContextArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsWithContextReturns(result1 error) { + fake.waitUntilStreamNotExistsWithContextMutex.Lock() + defer fake.waitUntilStreamNotExistsWithContextMutex.Unlock() + fake.WaitUntilStreamNotExistsWithContextStub = nil + fake.waitUntilStreamNotExistsWithContextReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) WaitUntilStreamNotExistsWithContextReturnsOnCall(i int, result1 error) { + fake.waitUntilStreamNotExistsWithContextMutex.Lock() + defer fake.waitUntilStreamNotExistsWithContextMutex.Unlock() + fake.WaitUntilStreamNotExistsWithContextStub = nil + if fake.waitUntilStreamNotExistsWithContextReturnsOnCall == nil { + fake.waitUntilStreamNotExistsWithContextReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.waitUntilStreamNotExistsWithContextReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeKinesisAPI) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.addTagsToStreamMutex.RLock() + defer fake.addTagsToStreamMutex.RUnlock() + fake.addTagsToStreamRequestMutex.RLock() + defer fake.addTagsToStreamRequestMutex.RUnlock() + fake.addTagsToStreamWithContextMutex.RLock() + defer fake.addTagsToStreamWithContextMutex.RUnlock() + fake.createStreamMutex.RLock() + defer fake.createStreamMutex.RUnlock() + fake.createStreamRequestMutex.RLock() + defer fake.createStreamRequestMutex.RUnlock() + fake.createStreamWithContextMutex.RLock() + defer fake.createStreamWithContextMutex.RUnlock() + fake.decreaseStreamRetentionPeriodMutex.RLock() + defer fake.decreaseStreamRetentionPeriodMutex.RUnlock() + fake.decreaseStreamRetentionPeriodRequestMutex.RLock() + defer fake.decreaseStreamRetentionPeriodRequestMutex.RUnlock() + fake.decreaseStreamRetentionPeriodWithContextMutex.RLock() + defer fake.decreaseStreamRetentionPeriodWithContextMutex.RUnlock() + fake.deleteStreamMutex.RLock() + defer fake.deleteStreamMutex.RUnlock() + fake.deleteStreamRequestMutex.RLock() + defer fake.deleteStreamRequestMutex.RUnlock() + fake.deleteStreamWithContextMutex.RLock() + defer fake.deleteStreamWithContextMutex.RUnlock() + fake.deregisterStreamConsumerMutex.RLock() + defer fake.deregisterStreamConsumerMutex.RUnlock() + fake.deregisterStreamConsumerRequestMutex.RLock() + defer fake.deregisterStreamConsumerRequestMutex.RUnlock() + fake.deregisterStreamConsumerWithContextMutex.RLock() + defer fake.deregisterStreamConsumerWithContextMutex.RUnlock() + fake.describeLimitsMutex.RLock() + defer fake.describeLimitsMutex.RUnlock() + fake.describeLimitsRequestMutex.RLock() + defer fake.describeLimitsRequestMutex.RUnlock() + fake.describeLimitsWithContextMutex.RLock() + defer fake.describeLimitsWithContextMutex.RUnlock() + fake.describeStreamMutex.RLock() + defer fake.describeStreamMutex.RUnlock() + fake.describeStreamConsumerMutex.RLock() + defer fake.describeStreamConsumerMutex.RUnlock() + fake.describeStreamConsumerRequestMutex.RLock() + defer fake.describeStreamConsumerRequestMutex.RUnlock() + fake.describeStreamConsumerWithContextMutex.RLock() + defer fake.describeStreamConsumerWithContextMutex.RUnlock() + fake.describeStreamPagesMutex.RLock() + defer fake.describeStreamPagesMutex.RUnlock() + fake.describeStreamPagesWithContextMutex.RLock() + defer fake.describeStreamPagesWithContextMutex.RUnlock() + fake.describeStreamRequestMutex.RLock() + defer fake.describeStreamRequestMutex.RUnlock() + fake.describeStreamSummaryMutex.RLock() + defer fake.describeStreamSummaryMutex.RUnlock() + fake.describeStreamSummaryRequestMutex.RLock() + defer fake.describeStreamSummaryRequestMutex.RUnlock() + fake.describeStreamSummaryWithContextMutex.RLock() + defer fake.describeStreamSummaryWithContextMutex.RUnlock() + fake.describeStreamWithContextMutex.RLock() + defer fake.describeStreamWithContextMutex.RUnlock() + fake.disableEnhancedMonitoringMutex.RLock() + defer fake.disableEnhancedMonitoringMutex.RUnlock() + fake.disableEnhancedMonitoringRequestMutex.RLock() + defer fake.disableEnhancedMonitoringRequestMutex.RUnlock() + fake.disableEnhancedMonitoringWithContextMutex.RLock() + defer fake.disableEnhancedMonitoringWithContextMutex.RUnlock() + fake.enableEnhancedMonitoringMutex.RLock() + defer fake.enableEnhancedMonitoringMutex.RUnlock() + fake.enableEnhancedMonitoringRequestMutex.RLock() + defer fake.enableEnhancedMonitoringRequestMutex.RUnlock() + fake.enableEnhancedMonitoringWithContextMutex.RLock() + defer fake.enableEnhancedMonitoringWithContextMutex.RUnlock() + fake.getRecordsMutex.RLock() + defer fake.getRecordsMutex.RUnlock() + fake.getRecordsRequestMutex.RLock() + defer fake.getRecordsRequestMutex.RUnlock() + fake.getRecordsWithContextMutex.RLock() + defer fake.getRecordsWithContextMutex.RUnlock() + fake.getShardIteratorMutex.RLock() + defer fake.getShardIteratorMutex.RUnlock() + fake.getShardIteratorRequestMutex.RLock() + defer fake.getShardIteratorRequestMutex.RUnlock() + fake.getShardIteratorWithContextMutex.RLock() + defer fake.getShardIteratorWithContextMutex.RUnlock() + fake.increaseStreamRetentionPeriodMutex.RLock() + defer fake.increaseStreamRetentionPeriodMutex.RUnlock() + fake.increaseStreamRetentionPeriodRequestMutex.RLock() + defer fake.increaseStreamRetentionPeriodRequestMutex.RUnlock() + fake.increaseStreamRetentionPeriodWithContextMutex.RLock() + defer fake.increaseStreamRetentionPeriodWithContextMutex.RUnlock() + fake.listShardsMutex.RLock() + defer fake.listShardsMutex.RUnlock() + fake.listShardsRequestMutex.RLock() + defer fake.listShardsRequestMutex.RUnlock() + fake.listShardsWithContextMutex.RLock() + defer fake.listShardsWithContextMutex.RUnlock() + fake.listStreamConsumersMutex.RLock() + defer fake.listStreamConsumersMutex.RUnlock() + fake.listStreamConsumersPagesMutex.RLock() + defer fake.listStreamConsumersPagesMutex.RUnlock() + fake.listStreamConsumersPagesWithContextMutex.RLock() + defer fake.listStreamConsumersPagesWithContextMutex.RUnlock() + fake.listStreamConsumersRequestMutex.RLock() + defer fake.listStreamConsumersRequestMutex.RUnlock() + fake.listStreamConsumersWithContextMutex.RLock() + defer fake.listStreamConsumersWithContextMutex.RUnlock() + fake.listStreamsMutex.RLock() + defer fake.listStreamsMutex.RUnlock() + fake.listStreamsPagesMutex.RLock() + defer fake.listStreamsPagesMutex.RUnlock() + fake.listStreamsPagesWithContextMutex.RLock() + defer fake.listStreamsPagesWithContextMutex.RUnlock() + fake.listStreamsRequestMutex.RLock() + defer fake.listStreamsRequestMutex.RUnlock() + fake.listStreamsWithContextMutex.RLock() + defer fake.listStreamsWithContextMutex.RUnlock() + fake.listTagsForStreamMutex.RLock() + defer fake.listTagsForStreamMutex.RUnlock() + fake.listTagsForStreamRequestMutex.RLock() + defer fake.listTagsForStreamRequestMutex.RUnlock() + fake.listTagsForStreamWithContextMutex.RLock() + defer fake.listTagsForStreamWithContextMutex.RUnlock() + fake.mergeShardsMutex.RLock() + defer fake.mergeShardsMutex.RUnlock() + fake.mergeShardsRequestMutex.RLock() + defer fake.mergeShardsRequestMutex.RUnlock() + fake.mergeShardsWithContextMutex.RLock() + defer fake.mergeShardsWithContextMutex.RUnlock() + fake.putRecordMutex.RLock() + defer fake.putRecordMutex.RUnlock() + fake.putRecordRequestMutex.RLock() + defer fake.putRecordRequestMutex.RUnlock() + fake.putRecordWithContextMutex.RLock() + defer fake.putRecordWithContextMutex.RUnlock() + fake.putRecordsMutex.RLock() + defer fake.putRecordsMutex.RUnlock() + fake.putRecordsRequestMutex.RLock() + defer fake.putRecordsRequestMutex.RUnlock() + fake.putRecordsWithContextMutex.RLock() + defer fake.putRecordsWithContextMutex.RUnlock() + fake.registerStreamConsumerMutex.RLock() + defer fake.registerStreamConsumerMutex.RUnlock() + fake.registerStreamConsumerRequestMutex.RLock() + defer fake.registerStreamConsumerRequestMutex.RUnlock() + fake.registerStreamConsumerWithContextMutex.RLock() + defer fake.registerStreamConsumerWithContextMutex.RUnlock() + fake.removeTagsFromStreamMutex.RLock() + defer fake.removeTagsFromStreamMutex.RUnlock() + fake.removeTagsFromStreamRequestMutex.RLock() + defer fake.removeTagsFromStreamRequestMutex.RUnlock() + fake.removeTagsFromStreamWithContextMutex.RLock() + defer fake.removeTagsFromStreamWithContextMutex.RUnlock() + fake.splitShardMutex.RLock() + defer fake.splitShardMutex.RUnlock() + fake.splitShardRequestMutex.RLock() + defer fake.splitShardRequestMutex.RUnlock() + fake.splitShardWithContextMutex.RLock() + defer fake.splitShardWithContextMutex.RUnlock() + fake.startStreamEncryptionMutex.RLock() + defer fake.startStreamEncryptionMutex.RUnlock() + fake.startStreamEncryptionRequestMutex.RLock() + defer fake.startStreamEncryptionRequestMutex.RUnlock() + fake.startStreamEncryptionWithContextMutex.RLock() + defer fake.startStreamEncryptionWithContextMutex.RUnlock() + fake.stopStreamEncryptionMutex.RLock() + defer fake.stopStreamEncryptionMutex.RUnlock() + fake.stopStreamEncryptionRequestMutex.RLock() + defer fake.stopStreamEncryptionRequestMutex.RUnlock() + fake.stopStreamEncryptionWithContextMutex.RLock() + defer fake.stopStreamEncryptionWithContextMutex.RUnlock() + fake.subscribeToShardMutex.RLock() + defer fake.subscribeToShardMutex.RUnlock() + fake.subscribeToShardRequestMutex.RLock() + defer fake.subscribeToShardRequestMutex.RUnlock() + fake.subscribeToShardWithContextMutex.RLock() + defer fake.subscribeToShardWithContextMutex.RUnlock() + fake.updateShardCountMutex.RLock() + defer fake.updateShardCountMutex.RUnlock() + fake.updateShardCountRequestMutex.RLock() + defer fake.updateShardCountRequestMutex.RUnlock() + fake.updateShardCountWithContextMutex.RLock() + defer fake.updateShardCountWithContextMutex.RUnlock() + fake.waitUntilStreamExistsMutex.RLock() + defer fake.waitUntilStreamExistsMutex.RUnlock() + fake.waitUntilStreamExistsWithContextMutex.RLock() + defer fake.waitUntilStreamExistsWithContextMutex.RUnlock() + fake.waitUntilStreamNotExistsMutex.RLock() + defer fake.waitUntilStreamNotExistsMutex.RUnlock() + fake.waitUntilStreamNotExistsWithContextMutex.RLock() + defer fake.waitUntilStreamNotExistsWithContextMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeKinesisAPI) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ kinesisiface.KinesisAPI = new(FakeKinesisAPI) diff --git a/backends/awskinesis/read.go b/backends/awskinesis/read.go new file mode 100644 index 00000000..03dbd0e8 --- /dev/null +++ b/backends/awskinesis/read.go @@ -0,0 +1,247 @@ +package awskinesis + +import ( + "context" + "encoding/json" + "sync" + "sync/atomic" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/kinesis" + "github.com/pkg/errors" + uuid "github.com/satori/go.uuid" + + "github.com/batchcorp/plumber/util" + "github.com/batchcorp/plumber/validate" + + "github.com/batchcorp/plumber-schemas/build/go/protos/args" + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + "github.com/batchcorp/plumber-schemas/build/go/protos/records" +) + +// getShardIterator creates a shard interator based on read arguments +// lastSequenceNumber argument is used when creating anther iterator after a recoverable read failure +func (k *Kinesis) getShardIterator(args *args.AWSKinesisReadArgs, shardID string, lastSequenceNumber *string) (*string, error) { + getOpts := &kinesis.GetShardIteratorInput{ + ShardId: aws.String(shardID), + StreamName: aws.String(args.Stream), + } + + if args.ReadTrimHorizon { + getOpts.ShardIteratorType = aws.String("TRIM_HORIZON") + } else if args.ReadSequenceNumber != "" { + getOpts.ShardIteratorType = aws.String("AT_SEQUENCE_NUMBER") + getOpts.StartingSequenceNumber = aws.String(args.ReadSequenceNumber) + } else if args.ReadFromTimestamp > 0 { + getOpts.ShardIteratorType = aws.String("AT_TIMESTAMP") + getOpts.Timestamp = aws.Time(time.Unix(int64(args.ReadFromTimestamp), 0)) + } else if args.ReadAfterSequenceNumber != "" { + getOpts.ShardIteratorType = aws.String("AFTER_SEQUENCE_NUMBER") + getOpts.StartingSequenceNumber = aws.String(args.ReadAfterSequenceNumber) + } else { + getOpts.ShardIteratorType = aws.String("LATEST") + } + + if lastSequenceNumber != nil { + getOpts.StartingSequenceNumber = lastSequenceNumber + } + + //Get shard iterator + shardResp, err := k.client.GetShardIterator(getOpts) + if err != nil { + return nil, err + } + + return shardResp.ShardIterator, nil +} + +// getShards returns a slice of all shards that exist for a stream +// This method is used when no --stream argument is provided. In this case, we will +// start a read for each available shard +func (k *Kinesis) getShards(args *args.AWSKinesisReadArgs) ([]string, error) { + shardResp, err := k.client.DescribeStream(&kinesis.DescribeStreamInput{ + StreamName: aws.String(args.Stream), + }) + if err != nil { + return nil, errors.Wrap(err, "unable to get shards") + } + + out := make([]string, 0) + + for _, shard := range shardResp.StreamDescription.Shards { + out = append(out, util.DerefString(shard.ShardId)) + } + + return out, nil +} + +// Read reads records from a Kinesis stream +func (k *Kinesis) Read(ctx context.Context, readOpts *opts.ReadOptions, resultsChan chan *records.ReadRecord, errorChan chan *records.ErrorRecord) error { + if err := validateReadOptions(readOpts); err != nil { + return errors.Wrap(err, "invalid read options") + } + + // Shared specofied by user, start a read for only that shard + if readOpts.AwsKinesis.Args.Shard != "" { + return k.readShard(ctx, readOpts.AwsKinesis.Args.Shard, readOpts, resultsChan, errorChan) + } + + // No shard specified. Get all shards and launch a goroutine to read each shard + shards, err := k.getShards(readOpts.AwsKinesis.Args) + if err != nil { + return errors.Wrap(err, "unable to get shards") + } + + var wg sync.WaitGroup + + for _, shardID := range shards { + wg.Add(1) + + go func(shardID string) { + defer wg.Done() + + k.log.Debugf("Launching read for shard '%s'", shardID) + + if err := k.readShard(ctx, shardID, readOpts, resultsChan, errorChan); err != nil { + util.WriteError(nil, errorChan, err) + } + }(shardID) + } + + wg.Wait() + + return nil +} + +// readShard reads from a single shard in a kinesis stream +func (k *Kinesis) readShard(ctx context.Context, shardID string, readOpts *opts.ReadOptions, resultsChan chan *records.ReadRecord, errorChan chan *records.ErrorRecord) error { + // In the event of a recoverable error, we want to start where we left off, if the user + // is reading by specific sequence number. Otherwise this value will be ignored + var lastSequenceNumber *string + + shardIterator, err := k.getShardIterator(readOpts.AwsKinesis.Args, shardID, lastSequenceNumber) + if err != nil { + return errors.Wrap(err, "unable to create shard iterator") + } + + k.log.Infof("Waiting for messages for shard '%s'...", shardID) + + for { + resp, err := k.client.GetRecordsWithContext(ctx, &kinesis.GetRecordsInput{ + ShardIterator: shardIterator, + Limit: aws.Int64(readOpts.AwsKinesis.Args.MaxRecords), + }) + if err != nil { + // Some errors are recoverable + if !canRetry(err) { + // Can't recover, exit out + util.WriteError(nil, errorChan, err) + return nil + } + + // Log so we know it happened, but no need to send error record to the client if we can recover + util.WriteError(k.log, nil, err) + + // Get new iterator. lastSequenceNumber is specified in the event that the user + // started reading from a specific sequence number. We want to start where we left off + shardIterator, err = k.getShardIterator(readOpts.AwsKinesis.Args, shardID, lastSequenceNumber) + if err != nil { + return errors.Wrap(err, "unable to create shard iterator") + } + + continue + } + + for _, msg := range resp.Records { + serializedMsg, err := json.Marshal(msg) + if err != nil { + return errors.Wrap(err, "unable to serialize message into JSON") + } + + // Count may be shared across multiple reads + atomic.AddUint64(&k.readCount, 1) + + resultsChan <- k.genReadRecord(msg, serializedMsg, shardID) + + lastSequenceNumber = msg.SequenceNumber + } + + if resp.NextShardIterator == nil || resp.NextShardIterator == shardIterator { + k.log.Info("No more messages in shard, stopping read") + break + } + + // NextShardIterator is a pagination key, it needs to be specified so that kinesis + // returns the next set of records, otherwise it will return the same records over and over + shardIterator = resp.NextShardIterator + + if !readOpts.Continuous { + break + } + + } + + return nil +} + +// genReadRecord returns a read record for a kinesis message. +// Keeping this in a separate method to keep Read() somewhat clean +func (k *Kinesis) genReadRecord(msg *kinesis.Record, serializedMsg []byte, shardID string) *records.ReadRecord { + return &records.ReadRecord{ + MessageId: uuid.NewV4().String(), + Num: int64(k.readCount), + ReceivedAtUnixTsUtc: time.Now().UTC().Unix(), + Payload: msg.Data, + XRaw: serializedMsg, + Record: &records.ReadRecord_AwsKinesis{ + AwsKinesis: &records.AWSKinesis{ + PartitionKey: util.DerefString(msg.PartitionKey), + SequenceNumber: util.DerefString(msg.SequenceNumber), + EncryptionType: util.DerefString(msg.EncryptionType), + ShardId: shardID, + Value: msg.Data, + }, + }, + } +} + +// canRetry determines if an error is recoverable +func canRetry(err error) bool { + switch err.(type) { + case *kinesis.ProvisionedThroughputExceededException: + // Exceeded limits, we can retry + return true + } + + return false +} + +func validateReadOptions(readOpts *opts.ReadOptions) error { + if readOpts == nil { + return validate.ErrMissingReadOptions + } + + if readOpts.AwsKinesis == nil { + return validate.ErrEmptyBackendGroup + } + + args := readOpts.AwsKinesis.Args + if args == nil { + return validate.ErrEmptyBackendArgs + } + + if args.Stream == "" { + return ErrEmptyStream + } + + if args.Shard == "" { + // If no shard is specified, then we will read from all shards + // However this won't work if reading via a sequence number, as those are unique to a shard + if args.ReadSequenceNumber != "" || args.ReadAfterSequenceNumber != "" { + return ErrEmptyShardWithSequence + } + } + + return nil +} diff --git a/backends/awskinesis/read_test.go b/backends/awskinesis/read_test.go new file mode 100644 index 00000000..0fdd5a00 --- /dev/null +++ b/backends/awskinesis/read_test.go @@ -0,0 +1,111 @@ +package awskinesis + +import ( + "context" + "io/ioutil" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/kinesis" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/sirupsen/logrus" + + "github.com/batchcorp/plumber-schemas/build/go/protos/args" + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + "github.com/batchcorp/plumber-schemas/build/go/protos/records" + + "github.com/batchcorp/plumber/backends/awskinesis/kinesisfakes" + "github.com/batchcorp/plumber/validate" +) + +var _ = Describe("AWS Kinesis Backend", func() { + var readOpts *opts.ReadOptions + + BeforeEach(func() { + readOpts = &opts.ReadOptions{ + AwsKinesis: &opts.ReadGroupAWSKinesisOptions{ + Args: &args.AWSKinesisReadArgs{ + Stream: "test", + Shard: "ShardId-0000000001", + MaxRecords: 1, + ReadLatest: true, + }, + }, + } + }) + + Context("validateReadOptions", func() { + It("validates nil read options", func() { + err := validateReadOptions(nil) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrMissingReadOptions)) + }) + It("validates missing backend group", func() { + readOpts.AwsKinesis = nil + err := validateReadOptions(readOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyBackendGroup)) + }) + It("validates missing backend args", func() { + readOpts.AwsKinesis.Args = nil + err := validateReadOptions(readOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyBackendArgs)) + }) + It("validates empty stream", func() { + readOpts.AwsKinesis.Args.Stream = "" + err := validateReadOptions(readOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(ErrEmptyStream)) + }) + + It("returns an error when reading from all shards, but with a sequence number specified", func() { + readOpts.AwsKinesis.Args.Shard = "" + readOpts.AwsKinesis.Args.ReadSequenceNumber = "123" + err := validateReadOptions(readOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(ErrEmptyShardWithSequence)) + }) + }) + + Context("Read", func() { + It("validates read options", func() { + err := (&Kinesis{}).Read(context.Background(), nil, nil, nil) + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring("invalid read options")) + }) + It("reads from Kinesis", func() { + errorsCh := make(chan *records.ErrorRecord, 1) + resultsCh := make(chan *records.ReadRecord, 1) + + fakeKinesis := &kinesisfakes.FakeKinesisAPI{} + fakeKinesis.GetRecordsWithContextStub = func(context.Context, *kinesis.GetRecordsInput, ...request.Option) (*kinesis.GetRecordsOutput, error) { + return &kinesis.GetRecordsOutput{ + Records: []*kinesis.Record{ + { + Data: []byte("test"), + }, + }, + }, nil + } + fakeKinesis.GetShardIteratorStub = func(*kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error) { + return &kinesis.GetShardIteratorOutput{ + ShardIterator: aws.String("test"), + }, nil + } + + a := &Kinesis{ + client: fakeKinesis, + log: logrus.NewEntry(&logrus.Logger{Out: ioutil.Discard}), + } + + err := a.Read(context.Background(), readOpts, resultsCh, errorsCh) + + Expect(err).ToNot(HaveOccurred()) + Expect(fakeKinesis.GetRecordsWithContextCallCount()).To(Equal(1)) + Expect(fakeKinesis.GetShardIteratorCallCount()).To(Equal(1)) + Expect(resultsCh).Should(Receive()) + }) + }) +}) diff --git a/backends/awskinesis/relay.go b/backends/awskinesis/relay.go new file mode 100644 index 00000000..962b75e8 --- /dev/null +++ b/backends/awskinesis/relay.go @@ -0,0 +1,13 @@ +package awskinesis + +import ( + "context" + + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + "github.com/batchcorp/plumber-schemas/build/go/protos/records" + "github.com/batchcorp/plumber/types" +) + +func (k *Kinesis) Relay(ctx context.Context, relayOpts *opts.RelayOptions, relayCh chan interface{}, errorCh chan *records.ErrorRecord) error { + return types.NotImplementedErr +} diff --git a/backends/awskinesis/relay_test.go b/backends/awskinesis/relay_test.go new file mode 100644 index 00000000..2804ecc4 --- /dev/null +++ b/backends/awskinesis/relay_test.go @@ -0,0 +1,18 @@ +package awskinesis + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "github.com/batchcorp/plumber/types" +) + +var _ = Describe("AWS Kinesis Backend", func() { + Context("Relay", func() { + It("returns not implemented error", func() { + err := (&Kinesis{}).Relay(nil, nil, nil, nil) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(types.NotImplementedErr)) + }) + }) +}) diff --git a/backends/awskinesis/write.go b/backends/awskinesis/write.go new file mode 100644 index 00000000..fa79023e --- /dev/null +++ b/backends/awskinesis/write.go @@ -0,0 +1,69 @@ +package awskinesis + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/kinesis" + "github.com/pkg/errors" + + "github.com/batchcorp/plumber/util" + "github.com/batchcorp/plumber/validate" + + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + "github.com/batchcorp/plumber-schemas/build/go/protos/records" +) + +func (k *Kinesis) Write(ctx context.Context, writeOpts *opts.WriteOptions, errorCh chan *records.ErrorRecord, messages ...*records.WriteRecord) error { + if err := validateWriteOptions(writeOpts); err != nil { + return errors.Wrap(err, "invalid write options") + } + + for _, msg := range messages { + var sequenceNumber *string + if writeOpts.AwsKinesis.Args.SequenceNumber != "" { + sequenceNumber = aws.String(writeOpts.AwsKinesis.Args.SequenceNumber) + } + + out, err := k.client.PutRecord(&kinesis.PutRecordInput{ + Data: []byte(msg.Input), + PartitionKey: aws.String(writeOpts.AwsKinesis.Args.PartitionKey), + SequenceNumberForOrdering: sequenceNumber, + StreamName: aws.String(writeOpts.AwsKinesis.Args.Stream), + }) + if err != nil { + util.WriteError(k.log, errorCh, err) + continue + } + + k.log.Infof("Wrote message to shard '%s' with sequence number '%s'", + util.DerefString(out.ShardId), util.DerefString(out.SequenceNumber)) + } + + return nil +} + +func validateWriteOptions(writeOpts *opts.WriteOptions) error { + if writeOpts == nil { + return validate.ErrEmptyWriteOpts + } + + if writeOpts.AwsKinesis == nil { + return validate.ErrEmptyBackendGroup + } + + args := writeOpts.AwsKinesis.Args + if args == nil { + return validate.ErrEmptyBackendArgs + } + + if args.Stream == "" { + return ErrEmptyStream + } + + if args.PartitionKey == "" { + return ErrEmptyPartitionKey + } + + return nil +} diff --git a/backends/awskinesis/write_test.go b/backends/awskinesis/write_test.go new file mode 100644 index 00000000..f2604293 --- /dev/null +++ b/backends/awskinesis/write_test.go @@ -0,0 +1,97 @@ +package awskinesis + +import ( + "context" + "io/ioutil" + + "github.com/aws/aws-sdk-go/service/kinesis" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "github.com/sirupsen/logrus" + + "github.com/batchcorp/plumber-schemas/build/go/protos/args" + "github.com/batchcorp/plumber-schemas/build/go/protos/opts" + "github.com/batchcorp/plumber-schemas/build/go/protos/records" + + "github.com/batchcorp/plumber/backends/awskinesis/kinesisfakes" + "github.com/batchcorp/plumber/validate" +) + +var _ = Describe("AWS Kinesis Backend", func() { + var writeOpts *opts.WriteOptions + + BeforeEach(func() { + writeOpts = &opts.WriteOptions{ + AwsKinesis: &opts.WriteGroupAWSKinesisOptions{ + Args: &args.AWSKinesisWriteArgs{ + Stream: "test", + PartitionKey: "test", + SequenceNumber: "1", + }, + }, + } + }) + + Context("validateWriteOptions", func() { + It("validates nil write options", func() { + err := validateWriteOptions(nil) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyWriteOpts)) + }) + It("validates nil backend group", func() { + writeOpts.AwsKinesis = nil + err := validateWriteOptions(writeOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyBackendGroup)) + }) + It("validates empty backend args", func() { + writeOpts.AwsKinesis.Args = nil + err := validateWriteOptions(writeOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(validate.ErrEmptyBackendArgs)) + }) + It("validates empty stream", func() { + writeOpts.AwsKinesis.Args.Stream = "" + err := validateWriteOptions(writeOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(ErrEmptyStream)) + }) + It("validates empty partition key", func() { + writeOpts.AwsKinesis.Args.PartitionKey = "" + err := validateWriteOptions(writeOpts) + Expect(err).To(HaveOccurred()) + Expect(err).To(Equal(ErrEmptyPartitionKey)) + }) + It("passes validation", func() { + err := validateWriteOptions(writeOpts) + Expect(err).ToNot(HaveOccurred()) + }) + }) + + Context("Write", func() { + It("validates write options", func() { + err := (&Kinesis{}).Write(context.Background(), nil, nil, nil) + Expect(err).To(HaveOccurred()) + Expect(err.Error()).To(ContainSubstring(validate.ErrEmptyWriteOpts.Error())) + }) + + It("should write a message to Kinesis", func() { + fakeKinesis := &kinesisfakes.FakeKinesisAPI{} + fakeKinesis.PutRecordStub = func(*kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) { + return &kinesis.PutRecordOutput{}, nil + } + + a := &Kinesis{ + client: fakeKinesis, + log: logrus.NewEntry(&logrus.Logger{Out: ioutil.Discard}), + } + + errorCh := make(chan *records.ErrorRecord, 1) + + err := a.Write(context.Background(), writeOpts, errorCh, &records.WriteRecord{Input: "test"}) + Expect(err).ToNot(HaveOccurred()) + Expect(fakeKinesis.PutRecordCallCount()).To(Equal(1)) + Expect(errorCh).ToNot(Receive()) + }) + }) +}) diff --git a/backends/awssns/awssns.go b/backends/awssns/awssns.go index 2f0b1385..399d3c2e 100644 --- a/backends/awssns/awssns.go +++ b/backends/awssns/awssns.go @@ -80,9 +80,22 @@ func validateBaseConnOpts(connOpts *opts.ConnectionOptions) error { return validate.ErrMissingConnCfg } - if connOpts.GetAwsSns() == nil { + args := connOpts.GetAwsSns() + if args == nil { return validate.ErrMissingConnArgs } + if args.AwsSecretAccessKey == "" { + return validate.ErrMissingAWSSecretAccessKey + } + + if args.AwsRegion == "" { + return validate.ErrMissingAWSRegion + } + + if args.AwsAccessKeyId == "" { + return validate.ErrMissingAWSAccessKeyID + } + return nil } diff --git a/backends/awssqs/awssqs.go b/backends/awssqs/awssqs.go index 136f76d6..f8e5513d 100644 --- a/backends/awssqs/awssqs.go +++ b/backends/awssqs/awssqs.go @@ -21,11 +21,9 @@ import ( const BackendName = "aws-sqs" var ( - ErrMissingQueue = errors.New("SQS Queue name cannot be empty") - ErrInvalidMaxNumMessages = errors.New("max number of messages must be between 1 and 10") - ErrInvalidWaitTime = errors.New("wait time seconds must be between 0 and 20") - ErrMissingAwsSecretAccessKey = errors.New("AWS Secret Access Key cannot be empty") - ErrMissingRegion = errors.New("AWS Region cannot be empty") + ErrMissingQueue = errors.New("SQS Queue name cannot be empty") + ErrInvalidMaxNumMessages = errors.New("max number of messages must be between 1 and 10") + ErrInvalidWaitTime = errors.New("wait time seconds must be between 0 and 20") ) type AWSSQS struct { @@ -93,11 +91,15 @@ func validateBaseConnOpts(connOpts *opts.ConnectionOptions) error { } if args.AwsSecretAccessKey == "" { - return ErrMissingAwsSecretAccessKey + return validate.ErrMissingAWSSecretAccessKey } if args.AwsRegion == "" { - return ErrMissingRegion + return validate.ErrMissingAWSRegion + } + + if args.AwsAccessKeyId == "" { + return validate.ErrMissingAWSAccessKeyID } return nil diff --git a/backends/awssqs/awssqs_test.go b/backends/awssqs/awssqs_test.go index 3ec760e2..236a05bd 100644 --- a/backends/awssqs/awssqs_test.go +++ b/backends/awssqs/awssqs_test.go @@ -48,13 +48,13 @@ var _ = Describe("AWSSQS Backend", func() { connOpts.GetAwsSqs().AwsSecretAccessKey = "" err := validateBaseConnOpts(connOpts) Expect(err).To(HaveOccurred()) - Expect(err).To(Equal(ErrMissingAwsSecretAccessKey)) + Expect(err).To(Equal(validate.ErrMissingAWSSecretAccessKey)) }) It("validates AWS region", func() { connOpts.GetAwsSqs().AwsRegion = "" err := validateBaseConnOpts(connOpts) Expect(err).To(HaveOccurred()) - Expect(err).To(Equal(ErrMissingRegion)) + Expect(err).To(Equal(validate.ErrMissingAWSRegion)) }) }) diff --git a/backends/awssqs/write_test.go b/backends/awssqs/write_test.go index 61d7fd8c..ad8ab5f2 100644 --- a/backends/awssqs/write_test.go +++ b/backends/awssqs/write_test.go @@ -37,7 +37,7 @@ var _ = Describe("AWSSQS Backend", func() { }) Context("validateWriteOptions", func() { - It("validates nil dynamic options", func() { + It("validates nil write options", func() { err := validateWriteOptions(nil) Expect(err).To(HaveOccurred()) Expect(err).To(Equal(validate.ErrEmptyWriteOpts)) diff --git a/backends/backends.go b/backends/backends.go index 8f0d4ccb..cc93f38c 100644 --- a/backends/backends.go +++ b/backends/backends.go @@ -6,6 +6,7 @@ import ( "github.com/pkg/errors" "github.com/batchcorp/plumber/backends/activemq" + "github.com/batchcorp/plumber/backends/awskinesis" "github.com/batchcorp/plumber/backends/awssns" "github.com/batchcorp/plumber/backends/awssqs" azureEventhub "github.com/batchcorp/plumber/backends/azure-eventhub" @@ -129,6 +130,8 @@ func New(connOpts *opts.ConnectionOptions) (Backend, error) { be, err = cdcpostgres.New(connOpts) case *opts.ConnectionOptions_NatsJetstream: be, err = natsJetstream.New(connOpts) + case *opts.ConnectionOptions_AwsKinesis: + be, err = awskinesis.New(connOpts) default: return nil, errors.New("unknown backend") diff --git a/docs/examples.md b/docs/examples.md index ffbeafe4..c2643077 100644 --- a/docs/examples.md +++ b/docs/examples.md @@ -17,6 +17,7 @@ * [Apache Pulsar](#apache-pulsar) * [NSQ](#nsq) * [Thrift Decoding](#thrift-decoding) + * [AWS Kinesis](#aws-kinesis) * [Publishing](#publishing) * [AWS SQS](#aws-sqs-1) * [AWS SNS](#aws-sns) @@ -33,6 +34,7 @@ * [MQTT](#mqtt-1) * [Apache Pulsar](#apache-pulsar-1) * [NSQ](#nsq-1) + * [AWS Kinesis](#aws-kinesis-1) * [Relay Mode](#relay-mode) * [Continuously relay messages from your RabbitMQ instance to a Batch.sh collection](#continuously-relay-messages-from-your-rabbitmq-instance-to-a-batchsh-collection) * [Continuously relay messages from an SQS queue to a Batch.sh collection](#continuously-relay-messages-from-an-sqs-queue-to-a-batchsh-collection) @@ -219,6 +221,18 @@ plumber read kafka --topics orders --decode-type thrift --pretty } ``` +#### AWS Kinesis + +Reading from a single shard +```bash +plumber read kinesis --stream orders --shard shardId-000000000000 --latest --max-records 10 +``` + +Read from all shards +```bash +plumber read kinesis --stream orders --continuous +``` + ## Publishing ##### AWS SQS @@ -343,7 +357,13 @@ plumber write pulsar --topic NEWORDERS --input="{\"order_id\": \"A-3458-654-1\", ##### NSQ ```bash -plumger write nsq --nsqd-address localhost:4050 --topic orders --input="{\"order_id\": \"A-3458-654-1\", \"status\": \"processed\"}" +plumber write nsq --nsqd-address localhost:4050 --topic orders --input="{\"order_id\": \"A-3458-654-1\", \"status\": \"processed\"}" +``` + +##### AWS Kinesis + +```bash +plumber write kinesis --stream teststream --partition-key orders --input "{\"order_id\": \"A-3458-654-1\", \"status\": \"processed\"}" ``` ## Relay Mode diff --git a/go.mod b/go.mod index c54513ec..c8c5caf8 100644 --- a/go.mod +++ b/go.mod @@ -11,7 +11,7 @@ require ( github.com/batchcorp/collector-schemas v0.0.5 github.com/batchcorp/kong v0.2.17-batch-fix github.com/batchcorp/pgoutput v0.3.2 - github.com/batchcorp/plumber-schemas v0.0.120 + github.com/batchcorp/plumber-schemas v0.0.121 github.com/batchcorp/rabbit v0.1.17 github.com/eclipse/paho.mqtt.golang v1.2.0 github.com/fatih/color v1.12.0 // indirect diff --git a/go.sum b/go.sum index 62f6e6aa..ead5a7e5 100644 --- a/go.sum +++ b/go.sum @@ -218,6 +218,8 @@ github.com/batchcorp/plumber-schemas v0.0.119 h1:eD4pEPLgjaawpwYZGmnl2yj/J7Z+Iw/ github.com/batchcorp/plumber-schemas v0.0.119/go.mod h1:YULMKnfZ8X7tglTfUzKXhWc1Bfq6dy5ysIQbvsbCOkY= github.com/batchcorp/plumber-schemas v0.0.120 h1:qiYduUtdV6rjTtpQmOiBuLRNZYhTr0KJ4N9KgD0yiK4= github.com/batchcorp/plumber-schemas v0.0.120/go.mod h1:YULMKnfZ8X7tglTfUzKXhWc1Bfq6dy5ysIQbvsbCOkY= +github.com/batchcorp/plumber-schemas v0.0.121 h1:nxdlIk18BPrloSpcu6NXibPw+zb3VHacDYVTO5YlCLg= +github.com/batchcorp/plumber-schemas v0.0.121/go.mod h1:YULMKnfZ8X7tglTfUzKXhWc1Bfq6dy5ysIQbvsbCOkY= github.com/batchcorp/rabbit v0.1.9 h1:BzQStzeo0WuvC7+PKYaEBYtn9qqramlaZCN1CxmNM6U= github.com/batchcorp/rabbit v0.1.9/go.mod h1:LaAQ6FCNkir0/SbJ9jX3JNNP1ULAU2M3QZN/IwFRwXw= github.com/batchcorp/rabbit v0.1.16 h1:TqyToURClYCPNiBzMOF0Cj87X1i9vLLZn0nG8PzawcE= diff --git a/options/options.go b/options/options.go index 4f48526d..a88a71e8 100644 --- a/options/options.go +++ b/options/options.go @@ -306,6 +306,10 @@ func newReadOptions() *opts.ReadOptions { XConn: &args.PostgresConn{}, Args: &args.PostgresReadArgs{}, }, + AwsKinesis: &opts.ReadGroupAWSKinesisOptions{ + XConn: &args.AWSKinesisConn{}, + Args: &args.AWSKinesisReadArgs{}, + }, } } @@ -416,6 +420,10 @@ func newWriteOptions() *opts.WriteOptions { XConn: &args.RedisStreamsConn{}, Args: &args.RedisStreamsWriteArgs{}, }, + AwsKinesis: &opts.WriteGroupAWSKinesisOptions{ + XConn: &args.AWSKinesisConn{}, + Args: &args.AWSKinesisWriteArgs{}, + }, } } @@ -567,6 +575,10 @@ func newDynamicOptions() *opts.DynamicOptions { XConn: &args.RedisStreamsConn{}, Args: &args.RedisStreamsWriteArgs{}, }, + AwsKinesis: &opts.DynamicGroupAWSKinesisOptions{ + XConn: &args.AWSKinesisConn{}, + Args: &args.AWSKinesisWriteArgs{}, + }, } } diff --git a/plumber/cli_read.go b/plumber/cli_read.go index e5fab91d..28983ad7 100644 --- a/plumber/cli_read.go +++ b/plumber/cli_read.go @@ -2,6 +2,7 @@ package plumber import ( "context" + "os" "github.com/pkg/errors" @@ -30,6 +31,7 @@ func (p *Plumber) HandleReadCmd() error { go func() { if err := backend.Read(context.Background(), p.CLIOptions.Read, resultCh, errorCh); err != nil { p.log.Errorf("unable to complete read for backend '%s': %s", backend.Name(), err) + os.Exit(0) // Exit out of plumber, since we can't continue } }() diff --git a/printer/printer.go b/printer/printer.go index d2411dae..7028dbd2 100644 --- a/printer/printer.go +++ b/printer/printer.go @@ -126,7 +126,7 @@ func displayTabular(count int64, receivedAt time.Time, data []byte, properties [ } table.SetColMinWidth(0, 20) - table.SetColMinWidth(1, 40) + table.SetColMinWidth(1, 60) // First column align left, second column align right table.SetColumnAlignment([]int{tablewriter.ALIGN_LEFT, tablewriter.ALIGN_RIGHT}) table.Render() diff --git a/validate/backends.go b/validate/backends.go index e1f8f1a5..c5ee32f0 100644 --- a/validate/backends.go +++ b/validate/backends.go @@ -6,14 +6,17 @@ var ( // Connection - ErrMissingConnOpts = errors.New("connection config cannot be nil") - ErrMissingConnCfg = errors.New("connection object in connection config cannot be nil") - ErrMissingConnArgs = errors.New("connection config args cannot be nil") - ErrMissingClientKey = errors.New("TLS key cannot be empty if TLS certificate is provided") - ErrMissingClientCert = errors.New("TLS certificate cannot be empty if TLS key is provided") - ErrMissingDSN = errors.New("DSN cannot be empty") - ErrInvalidConnTimeout = errors.New("connection timeout must be greater than zero") - ErrMissingAddress = errors.New("address cannot be empty") + ErrMissingConnOpts = errors.New("connection config cannot be nil") + ErrMissingConnCfg = errors.New("connection object in connection config cannot be nil") + ErrMissingConnArgs = errors.New("connection config args cannot be nil") + ErrMissingClientKey = errors.New("TLS key cannot be empty if TLS certificate is provided") + ErrMissingClientCert = errors.New("TLS certificate cannot be empty if TLS key is provided") + ErrMissingDSN = errors.New("DSN cannot be empty") + ErrInvalidConnTimeout = errors.New("connection timeout must be greater than zero") + ErrMissingAddress = errors.New("address cannot be empty") + ErrMissingAWSSecretAccessKey = errors.New("AWS Secret Access Key cannot be empty") + ErrMissingAWSRegion = errors.New("AWS Region cannot be empty") + ErrMissingAWSAccessKeyID = errors.New("AWS Access Key ID cannot be empty") // Relay / Display diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.go new file mode 100644 index 00000000..15105497 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.go @@ -0,0 +1,144 @@ +package eventstream + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "fmt" + "strconv" +) + +type decodedMessage struct { + rawMessage + Headers decodedHeaders `json:"headers"` +} +type jsonMessage struct { + Length json.Number `json:"total_length"` + HeadersLen json.Number `json:"headers_length"` + PreludeCRC json.Number `json:"prelude_crc"` + Headers decodedHeaders `json:"headers"` + Payload []byte `json:"payload"` + CRC json.Number `json:"message_crc"` +} + +func (d *decodedMessage) UnmarshalJSON(b []byte) (err error) { + var jsonMsg jsonMessage + if err = json.Unmarshal(b, &jsonMsg); err != nil { + return err + } + + d.Length, err = numAsUint32(jsonMsg.Length) + if err != nil { + return err + } + d.HeadersLen, err = numAsUint32(jsonMsg.HeadersLen) + if err != nil { + return err + } + d.PreludeCRC, err = numAsUint32(jsonMsg.PreludeCRC) + if err != nil { + return err + } + d.Headers = jsonMsg.Headers + d.Payload = jsonMsg.Payload + d.CRC, err = numAsUint32(jsonMsg.CRC) + if err != nil { + return err + } + + return nil +} + +func (d *decodedMessage) MarshalJSON() ([]byte, error) { + jsonMsg := jsonMessage{ + Length: json.Number(strconv.Itoa(int(d.Length))), + HeadersLen: json.Number(strconv.Itoa(int(d.HeadersLen))), + PreludeCRC: json.Number(strconv.Itoa(int(d.PreludeCRC))), + Headers: d.Headers, + Payload: d.Payload, + CRC: json.Number(strconv.Itoa(int(d.CRC))), + } + + return json.Marshal(jsonMsg) +} + +func numAsUint32(n json.Number) (uint32, error) { + v, err := n.Int64() + if err != nil { + return 0, fmt.Errorf("failed to get int64 json number, %v", err) + } + + return uint32(v), nil +} + +func (d decodedMessage) Message() Message { + return Message{ + Headers: Headers(d.Headers), + Payload: d.Payload, + } +} + +type decodedHeaders Headers + +func (hs *decodedHeaders) UnmarshalJSON(b []byte) error { + var jsonHeaders []struct { + Name string `json:"name"` + Type valueType `json:"type"` + Value interface{} `json:"value"` + } + + decoder := json.NewDecoder(bytes.NewReader(b)) + decoder.UseNumber() + if err := decoder.Decode(&jsonHeaders); err != nil { + return err + } + + var headers Headers + for _, h := range jsonHeaders { + value, err := valueFromType(h.Type, h.Value) + if err != nil { + return err + } + headers.Set(h.Name, value) + } + *hs = decodedHeaders(headers) + + return nil +} + +func valueFromType(typ valueType, val interface{}) (Value, error) { + switch typ { + case trueValueType: + return BoolValue(true), nil + case falseValueType: + return BoolValue(false), nil + case int8ValueType: + v, err := val.(json.Number).Int64() + return Int8Value(int8(v)), err + case int16ValueType: + v, err := val.(json.Number).Int64() + return Int16Value(int16(v)), err + case int32ValueType: + v, err := val.(json.Number).Int64() + return Int32Value(int32(v)), err + case int64ValueType: + v, err := val.(json.Number).Int64() + return Int64Value(v), err + case bytesValueType: + v, err := base64.StdEncoding.DecodeString(val.(string)) + return BytesValue(v), err + case stringValueType: + v, err := base64.StdEncoding.DecodeString(val.(string)) + return StringValue(string(v)), err + case timestampValueType: + v, err := val.(json.Number).Int64() + return TimestampValue(timeFromEpochMilli(v)), err + case uuidValueType: + v, err := base64.StdEncoding.DecodeString(val.(string)) + var tv UUIDValue + copy(tv[:], v) + return tv, err + default: + panic(fmt.Sprintf("unknown type, %s, %T", typ.String(), val)) + } +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.go new file mode 100644 index 00000000..47433939 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.go @@ -0,0 +1,216 @@ +package eventstream + +import ( + "bytes" + "encoding/binary" + "encoding/hex" + "encoding/json" + "fmt" + "hash" + "hash/crc32" + "io" + + "github.com/aws/aws-sdk-go/aws" +) + +// Decoder provides decoding of an Event Stream messages. +type Decoder struct { + r io.Reader + logger aws.Logger +} + +// NewDecoder initializes and returns a Decoder for decoding event +// stream messages from the reader provided. +func NewDecoder(r io.Reader, opts ...func(*Decoder)) *Decoder { + d := &Decoder{ + r: r, + } + + for _, opt := range opts { + opt(d) + } + + return d +} + +// DecodeWithLogger adds a logger to be used by the decoder when decoding +// stream events. +func DecodeWithLogger(logger aws.Logger) func(*Decoder) { + return func(d *Decoder) { + d.logger = logger + } +} + +// Decode attempts to decode a single message from the event stream reader. +// Will return the event stream message, or error if Decode fails to read +// the message from the stream. +func (d *Decoder) Decode(payloadBuf []byte) (m Message, err error) { + reader := d.r + if d.logger != nil { + debugMsgBuf := bytes.NewBuffer(nil) + reader = io.TeeReader(reader, debugMsgBuf) + defer func() { + logMessageDecode(d.logger, debugMsgBuf, m, err) + }() + } + + m, err = Decode(reader, payloadBuf) + + return m, err +} + +// Decode attempts to decode a single message from the event stream reader. +// Will return the event stream message, or error if Decode fails to read +// the message from the reader. +func Decode(reader io.Reader, payloadBuf []byte) (m Message, err error) { + crc := crc32.New(crc32IEEETable) + hashReader := io.TeeReader(reader, crc) + + prelude, err := decodePrelude(hashReader, crc) + if err != nil { + return Message{}, err + } + + if prelude.HeadersLen > 0 { + lr := io.LimitReader(hashReader, int64(prelude.HeadersLen)) + m.Headers, err = decodeHeaders(lr) + if err != nil { + return Message{}, err + } + } + + if payloadLen := prelude.PayloadLen(); payloadLen > 0 { + buf, err := decodePayload(payloadBuf, io.LimitReader(hashReader, int64(payloadLen))) + if err != nil { + return Message{}, err + } + m.Payload = buf + } + + msgCRC := crc.Sum32() + if err := validateCRC(reader, msgCRC); err != nil { + return Message{}, err + } + + return m, nil +} + +func logMessageDecode(logger aws.Logger, msgBuf *bytes.Buffer, msg Message, decodeErr error) { + w := bytes.NewBuffer(nil) + defer func() { logger.Log(w.String()) }() + + fmt.Fprintf(w, "Raw message:\n%s\n", + hex.Dump(msgBuf.Bytes())) + + if decodeErr != nil { + fmt.Fprintf(w, "Decode error: %v\n", decodeErr) + return + } + + rawMsg, err := msg.rawMessage() + if err != nil { + fmt.Fprintf(w, "failed to create raw message, %v\n", err) + return + } + + decodedMsg := decodedMessage{ + rawMessage: rawMsg, + Headers: decodedHeaders(msg.Headers), + } + + fmt.Fprintf(w, "Decoded message:\n") + encoder := json.NewEncoder(w) + if err := encoder.Encode(decodedMsg); err != nil { + fmt.Fprintf(w, "failed to generate decoded message, %v\n", err) + } +} + +func decodePrelude(r io.Reader, crc hash.Hash32) (messagePrelude, error) { + var p messagePrelude + + var err error + p.Length, err = decodeUint32(r) + if err != nil { + return messagePrelude{}, err + } + + p.HeadersLen, err = decodeUint32(r) + if err != nil { + return messagePrelude{}, err + } + + if err := p.ValidateLens(); err != nil { + return messagePrelude{}, err + } + + preludeCRC := crc.Sum32() + if err := validateCRC(r, preludeCRC); err != nil { + return messagePrelude{}, err + } + + p.PreludeCRC = preludeCRC + + return p, nil +} + +func decodePayload(buf []byte, r io.Reader) ([]byte, error) { + w := bytes.NewBuffer(buf[0:0]) + + _, err := io.Copy(w, r) + return w.Bytes(), err +} + +func decodeUint8(r io.Reader) (uint8, error) { + type byteReader interface { + ReadByte() (byte, error) + } + + if br, ok := r.(byteReader); ok { + v, err := br.ReadByte() + return uint8(v), err + } + + var b [1]byte + _, err := io.ReadFull(r, b[:]) + return uint8(b[0]), err +} +func decodeUint16(r io.Reader) (uint16, error) { + var b [2]byte + bs := b[:] + _, err := io.ReadFull(r, bs) + if err != nil { + return 0, err + } + return binary.BigEndian.Uint16(bs), nil +} +func decodeUint32(r io.Reader) (uint32, error) { + var b [4]byte + bs := b[:] + _, err := io.ReadFull(r, bs) + if err != nil { + return 0, err + } + return binary.BigEndian.Uint32(bs), nil +} +func decodeUint64(r io.Reader) (uint64, error) { + var b [8]byte + bs := b[:] + _, err := io.ReadFull(r, bs) + if err != nil { + return 0, err + } + return binary.BigEndian.Uint64(bs), nil +} + +func validateCRC(r io.Reader, expect uint32) error { + msgCRC, err := decodeUint32(r) + if err != nil { + return err + } + + if msgCRC != expect { + return ChecksumError{} + } + + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.go new file mode 100644 index 00000000..ffade3bc --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.go @@ -0,0 +1,162 @@ +package eventstream + +import ( + "bytes" + "encoding/binary" + "encoding/hex" + "encoding/json" + "fmt" + "hash" + "hash/crc32" + "io" + + "github.com/aws/aws-sdk-go/aws" +) + +// Encoder provides EventStream message encoding. +type Encoder struct { + w io.Writer + logger aws.Logger + + headersBuf *bytes.Buffer +} + +// NewEncoder initializes and returns an Encoder to encode Event Stream +// messages to an io.Writer. +func NewEncoder(w io.Writer, opts ...func(*Encoder)) *Encoder { + e := &Encoder{ + w: w, + headersBuf: bytes.NewBuffer(nil), + } + + for _, opt := range opts { + opt(e) + } + + return e +} + +// EncodeWithLogger adds a logger to be used by the encode when decoding +// stream events. +func EncodeWithLogger(logger aws.Logger) func(*Encoder) { + return func(d *Encoder) { + d.logger = logger + } +} + +// Encode encodes a single EventStream message to the io.Writer the Encoder +// was created with. An error is returned if writing the message fails. +func (e *Encoder) Encode(msg Message) (err error) { + e.headersBuf.Reset() + + writer := e.w + if e.logger != nil { + encodeMsgBuf := bytes.NewBuffer(nil) + writer = io.MultiWriter(writer, encodeMsgBuf) + defer func() { + logMessageEncode(e.logger, encodeMsgBuf, msg, err) + }() + } + + if err = EncodeHeaders(e.headersBuf, msg.Headers); err != nil { + return err + } + + crc := crc32.New(crc32IEEETable) + hashWriter := io.MultiWriter(writer, crc) + + headersLen := uint32(e.headersBuf.Len()) + payloadLen := uint32(len(msg.Payload)) + + if err = encodePrelude(hashWriter, crc, headersLen, payloadLen); err != nil { + return err + } + + if headersLen > 0 { + if _, err = io.Copy(hashWriter, e.headersBuf); err != nil { + return err + } + } + + if payloadLen > 0 { + if _, err = hashWriter.Write(msg.Payload); err != nil { + return err + } + } + + msgCRC := crc.Sum32() + return binary.Write(writer, binary.BigEndian, msgCRC) +} + +func logMessageEncode(logger aws.Logger, msgBuf *bytes.Buffer, msg Message, encodeErr error) { + w := bytes.NewBuffer(nil) + defer func() { logger.Log(w.String()) }() + + fmt.Fprintf(w, "Message to encode:\n") + encoder := json.NewEncoder(w) + if err := encoder.Encode(msg); err != nil { + fmt.Fprintf(w, "Failed to get encoded message, %v\n", err) + } + + if encodeErr != nil { + fmt.Fprintf(w, "Encode error: %v\n", encodeErr) + return + } + + fmt.Fprintf(w, "Raw message:\n%s\n", hex.Dump(msgBuf.Bytes())) +} + +func encodePrelude(w io.Writer, crc hash.Hash32, headersLen, payloadLen uint32) error { + p := messagePrelude{ + Length: minMsgLen + headersLen + payloadLen, + HeadersLen: headersLen, + } + if err := p.ValidateLens(); err != nil { + return err + } + + err := binaryWriteFields(w, binary.BigEndian, + p.Length, + p.HeadersLen, + ) + if err != nil { + return err + } + + p.PreludeCRC = crc.Sum32() + err = binary.Write(w, binary.BigEndian, p.PreludeCRC) + if err != nil { + return err + } + + return nil +} + +// EncodeHeaders writes the header values to the writer encoded in the event +// stream format. Returns an error if a header fails to encode. +func EncodeHeaders(w io.Writer, headers Headers) error { + for _, h := range headers { + hn := headerName{ + Len: uint8(len(h.Name)), + } + copy(hn.Name[:hn.Len], h.Name) + if err := hn.encode(w); err != nil { + return err + } + + if err := h.Value.encode(w); err != nil { + return err + } + } + + return nil +} + +func binaryWriteFields(w io.Writer, order binary.ByteOrder, vs ...interface{}) error { + for _, v := range vs { + if err := binary.Write(w, order, v); err != nil { + return err + } + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go new file mode 100644 index 00000000..5481ef30 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go @@ -0,0 +1,23 @@ +package eventstream + +import "fmt" + +// LengthError provides the error for items being larger than a maximum length. +type LengthError struct { + Part string + Want int + Have int + Value interface{} +} + +func (e LengthError) Error() string { + return fmt.Sprintf("%s length invalid, %d/%d, %v", + e.Part, e.Want, e.Have, e.Value) +} + +// ChecksumError provides the error for message checksum invalidation errors. +type ChecksumError struct{} + +func (e ChecksumError) Error() string { + return "message checksum mismatch" +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go new file mode 100644 index 00000000..34c2e89d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go @@ -0,0 +1,77 @@ +package eventstreamapi + +import ( + "fmt" + "sync" +) + +type messageError struct { + code string + msg string +} + +func (e messageError) Code() string { + return e.code +} + +func (e messageError) Message() string { + return e.msg +} + +func (e messageError) Error() string { + return fmt.Sprintf("%s: %s", e.code, e.msg) +} + +func (e messageError) OrigErr() error { + return nil +} + +// OnceError wraps the behavior of recording an error +// once and signal on a channel when this has occurred. +// Signaling is done by closing of the channel. +// +// Type is safe for concurrent usage. +type OnceError struct { + mu sync.RWMutex + err error + ch chan struct{} +} + +// NewOnceError return a new OnceError +func NewOnceError() *OnceError { + return &OnceError{ + ch: make(chan struct{}, 1), + } +} + +// Err acquires a read-lock and returns an +// error if one has been set. +func (e *OnceError) Err() error { + e.mu.RLock() + err := e.err + e.mu.RUnlock() + + return err +} + +// SetError acquires a write-lock and will set +// the underlying error value if one has not been set. +func (e *OnceError) SetError(err error) { + if err == nil { + return + } + + e.mu.Lock() + if e.err == nil { + e.err = err + close(e.ch) + } + e.mu.Unlock() +} + +// ErrorSet returns a channel that will be used to signal +// that an error has been set. This channel will be closed +// when the error value has been set for OnceError. +func (e *OnceError) ErrorSet() <-chan struct{} { + return e.ch +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/reader.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/reader.go new file mode 100644 index 00000000..0e4aa42f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/reader.go @@ -0,0 +1,173 @@ +package eventstreamapi + +import ( + "fmt" + + "github.com/aws/aws-sdk-go/private/protocol" + "github.com/aws/aws-sdk-go/private/protocol/eventstream" +) + +// Unmarshaler provides the interface for unmarshaling a EventStream +// message into a SDK type. +type Unmarshaler interface { + UnmarshalEvent(protocol.PayloadUnmarshaler, eventstream.Message) error +} + +// EventReader provides reading from the EventStream of an reader. +type EventReader struct { + decoder *eventstream.Decoder + + unmarshalerForEventType func(string) (Unmarshaler, error) + payloadUnmarshaler protocol.PayloadUnmarshaler + + payloadBuf []byte +} + +// NewEventReader returns a EventReader built from the reader and unmarshaler +// provided. Use ReadStream method to start reading from the EventStream. +func NewEventReader( + decoder *eventstream.Decoder, + payloadUnmarshaler protocol.PayloadUnmarshaler, + unmarshalerForEventType func(string) (Unmarshaler, error), +) *EventReader { + return &EventReader{ + decoder: decoder, + payloadUnmarshaler: payloadUnmarshaler, + unmarshalerForEventType: unmarshalerForEventType, + payloadBuf: make([]byte, 10*1024), + } +} + +// ReadEvent attempts to read a message from the EventStream and return the +// unmarshaled event value that the message is for. +// +// For EventStream API errors check if the returned error satisfies the +// awserr.Error interface to get the error's Code and Message components. +// +// EventUnmarshalers called with EventStream messages must take copies of the +// message's Payload. The payload will is reused between events read. +func (r *EventReader) ReadEvent() (event interface{}, err error) { + msg, err := r.decoder.Decode(r.payloadBuf) + if err != nil { + return nil, err + } + defer func() { + // Reclaim payload buffer for next message read. + r.payloadBuf = msg.Payload[0:0] + }() + + typ, err := GetHeaderString(msg, MessageTypeHeader) + if err != nil { + return nil, err + } + + switch typ { + case EventMessageType: + return r.unmarshalEventMessage(msg) + case ExceptionMessageType: + return nil, r.unmarshalEventException(msg) + case ErrorMessageType: + return nil, r.unmarshalErrorMessage(msg) + default: + return nil, &UnknownMessageTypeError{ + Type: typ, Message: msg.Clone(), + } + } +} + +// UnknownMessageTypeError provides an error when a message is received from +// the stream, but the reader is unable to determine what kind of message it is. +type UnknownMessageTypeError struct { + Type string + Message eventstream.Message +} + +func (e *UnknownMessageTypeError) Error() string { + return "unknown eventstream message type, " + e.Type +} + +func (r *EventReader) unmarshalEventMessage( + msg eventstream.Message, +) (event interface{}, err error) { + eventType, err := GetHeaderString(msg, EventTypeHeader) + if err != nil { + return nil, err + } + + ev, err := r.unmarshalerForEventType(eventType) + if err != nil { + return nil, err + } + + err = ev.UnmarshalEvent(r.payloadUnmarshaler, msg) + if err != nil { + return nil, err + } + + return ev, nil +} + +func (r *EventReader) unmarshalEventException( + msg eventstream.Message, +) (err error) { + eventType, err := GetHeaderString(msg, ExceptionTypeHeader) + if err != nil { + return err + } + + ev, err := r.unmarshalerForEventType(eventType) + if err != nil { + return err + } + + err = ev.UnmarshalEvent(r.payloadUnmarshaler, msg) + if err != nil { + return err + } + + var ok bool + err, ok = ev.(error) + if !ok { + err = messageError{ + code: "SerializationError", + msg: fmt.Sprintf( + "event stream exception %s mapped to non-error %T, %v", + eventType, ev, ev, + ), + } + } + + return err +} + +func (r *EventReader) unmarshalErrorMessage(msg eventstream.Message) (err error) { + var msgErr messageError + + msgErr.code, err = GetHeaderString(msg, ErrorCodeHeader) + if err != nil { + return err + } + + msgErr.msg, err = GetHeaderString(msg, ErrorMessageHeader) + if err != nil { + return err + } + + return msgErr +} + +// GetHeaderString returns the value of the header as a string. If the header +// is not set or the value is not a string an error will be returned. +func GetHeaderString(msg eventstream.Message, headerName string) (string, error) { + headerVal := msg.Headers.Get(headerName) + if headerVal == nil { + return "", fmt.Errorf("error header %s not present", headerName) + } + + v, ok := headerVal.Get().(string) + if !ok { + return "", fmt.Errorf("error header value is not a string, %T", headerVal) + } + + return v, nil +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/shared.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/shared.go new file mode 100644 index 00000000..e46b8acc --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/shared.go @@ -0,0 +1,23 @@ +package eventstreamapi + +// EventStream headers with specific meaning to async API functionality. +const ( + ChunkSignatureHeader = `:chunk-signature` // chunk signature for message + DateHeader = `:date` // Date header for signature + + // Message header and values + MessageTypeHeader = `:message-type` // Identifies type of message. + EventMessageType = `event` + ErrorMessageType = `error` + ExceptionMessageType = `exception` + + // Message Events + EventTypeHeader = `:event-type` // Identifies message event type e.g. "Stats". + + // Message Error + ErrorCodeHeader = `:error-code` + ErrorMessageHeader = `:error-message` + + // Message Exception + ExceptionTypeHeader = `:exception-type` +) diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/signer.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/signer.go new file mode 100644 index 00000000..3a7ba5cd --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/signer.go @@ -0,0 +1,123 @@ +package eventstreamapi + +import ( + "bytes" + "strings" + "time" + + "github.com/aws/aws-sdk-go/private/protocol/eventstream" +) + +var timeNow = time.Now + +// StreamSigner defines an interface for the implementation of signing of event stream payloads +type StreamSigner interface { + GetSignature(headers, payload []byte, date time.Time) ([]byte, error) +} + +// SignEncoder envelopes event stream messages +// into an event stream message payload with included +// signature headers using the provided signer and encoder. +type SignEncoder struct { + signer StreamSigner + encoder Encoder + bufEncoder *BufferEncoder + + closeErr error + closed bool +} + +// NewSignEncoder returns a new SignEncoder using the provided stream signer and +// event stream encoder. +func NewSignEncoder(signer StreamSigner, encoder Encoder) *SignEncoder { + // TODO: Need to pass down logging + + return &SignEncoder{ + signer: signer, + encoder: encoder, + bufEncoder: NewBufferEncoder(), + } +} + +// Close encodes a final event stream signing envelope with an empty event stream +// payload. This final end-frame is used to mark the conclusion of the stream. +func (s *SignEncoder) Close() error { + if s.closed { + return s.closeErr + } + + if err := s.encode([]byte{}); err != nil { + if strings.Contains(err.Error(), "on closed pipe") { + return nil + } + + s.closeErr = err + s.closed = true + return s.closeErr + } + + return nil +} + +// Encode takes the provided message and add envelopes the message +// with the required signature. +func (s *SignEncoder) Encode(msg eventstream.Message) error { + payload, err := s.bufEncoder.Encode(msg) + if err != nil { + return err + } + + return s.encode(payload) +} + +func (s SignEncoder) encode(payload []byte) error { + date := timeNow() + + var msg eventstream.Message + msg.Headers.Set(DateHeader, eventstream.TimestampValue(date)) + msg.Payload = payload + + var headers bytes.Buffer + if err := eventstream.EncodeHeaders(&headers, msg.Headers); err != nil { + return err + } + + sig, err := s.signer.GetSignature(headers.Bytes(), msg.Payload, date) + if err != nil { + return err + } + + msg.Headers.Set(ChunkSignatureHeader, eventstream.BytesValue(sig)) + + return s.encoder.Encode(msg) +} + +// BufferEncoder is a utility that provides a buffered +// event stream encoder +type BufferEncoder struct { + encoder Encoder + buffer *bytes.Buffer +} + +// NewBufferEncoder returns a new BufferEncoder initialized +// with a 1024 byte buffer. +func NewBufferEncoder() *BufferEncoder { + buf := bytes.NewBuffer(make([]byte, 1024)) + return &BufferEncoder{ + encoder: eventstream.NewEncoder(buf), + buffer: buf, + } +} + +// Encode returns the encoded message as a byte slice. +// The returned byte slice will be modified on the next encode call +// and should not be held onto. +func (e *BufferEncoder) Encode(msg eventstream.Message) ([]byte, error) { + e.buffer.Reset() + + if err := e.encoder.Encode(msg); err != nil { + return nil, err + } + + return e.buffer.Bytes(), nil +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/stream_writer.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/stream_writer.go new file mode 100644 index 00000000..433bb163 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/stream_writer.go @@ -0,0 +1,129 @@ +package eventstreamapi + +import ( + "fmt" + "io" + "sync" + + "github.com/aws/aws-sdk-go/aws" +) + +// StreamWriter provides concurrent safe writing to an event stream. +type StreamWriter struct { + eventWriter *EventWriter + stream chan eventWriteAsyncReport + + done chan struct{} + closeOnce sync.Once + err *OnceError + + streamCloser io.Closer +} + +// NewStreamWriter returns a StreamWriter for the event writer, and stream +// closer provided. +func NewStreamWriter(eventWriter *EventWriter, streamCloser io.Closer) *StreamWriter { + w := &StreamWriter{ + eventWriter: eventWriter, + streamCloser: streamCloser, + stream: make(chan eventWriteAsyncReport), + done: make(chan struct{}), + err: NewOnceError(), + } + go w.writeStream() + + return w +} + +// Close terminates the writers ability to write new events to the stream. Any +// future call to Send will fail with an error. +func (w *StreamWriter) Close() error { + w.closeOnce.Do(w.safeClose) + return w.Err() +} + +func (w *StreamWriter) safeClose() { + close(w.done) +} + +// ErrorSet returns a channel which will be closed +// if an error occurs. +func (w *StreamWriter) ErrorSet() <-chan struct{} { + return w.err.ErrorSet() +} + +// Err returns any error that occurred while attempting to write an event to the +// stream. +func (w *StreamWriter) Err() error { + return w.err.Err() +} + +// Send writes a single event to the stream returning an error if the write +// failed. +// +// Send may be called concurrently. Events will be written to the stream +// safely. +func (w *StreamWriter) Send(ctx aws.Context, event Marshaler) error { + if err := w.Err(); err != nil { + return err + } + + resultCh := make(chan error) + wrapped := eventWriteAsyncReport{ + Event: event, + Result: resultCh, + } + + select { + case w.stream <- wrapped: + case <-ctx.Done(): + return ctx.Err() + case <-w.done: + return fmt.Errorf("stream closed, unable to send event") + } + + select { + case err := <-resultCh: + return err + case <-ctx.Done(): + return ctx.Err() + case <-w.done: + return fmt.Errorf("stream closed, unable to send event") + } +} + +func (w *StreamWriter) writeStream() { + defer w.Close() + + for { + select { + case wrapper := <-w.stream: + err := w.eventWriter.WriteEvent(wrapper.Event) + wrapper.ReportResult(w.done, err) + if err != nil { + w.err.SetError(err) + return + } + + case <-w.done: + if err := w.streamCloser.Close(); err != nil { + w.err.SetError(err) + } + return + } + } +} + +type eventWriteAsyncReport struct { + Event Marshaler + Result chan<- error +} + +func (e eventWriteAsyncReport) ReportResult(cancel <-chan struct{}, err error) bool { + select { + case e.Result <- err: + return true + case <-cancel: + return false + } +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/writer.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/writer.go new file mode 100644 index 00000000..10a3823d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/writer.go @@ -0,0 +1,109 @@ +package eventstreamapi + +import ( + "github.com/aws/aws-sdk-go/private/protocol" + "github.com/aws/aws-sdk-go/private/protocol/eventstream" +) + +// Marshaler provides a marshaling interface for event types to event stream +// messages. +type Marshaler interface { + MarshalEvent(protocol.PayloadMarshaler) (eventstream.Message, error) +} + +// Encoder is an stream encoder that will encode an event stream message for +// the transport. +type Encoder interface { + Encode(eventstream.Message) error +} + +// EventWriter provides a wrapper around the underlying event stream encoder +// for an io.WriteCloser. +type EventWriter struct { + encoder Encoder + payloadMarshaler protocol.PayloadMarshaler + eventTypeFor func(Marshaler) (string, error) +} + +// NewEventWriter returns a new event stream writer, that will write to the +// writer provided. Use the WriteEvent method to write an event to the stream. +func NewEventWriter(encoder Encoder, pm protocol.PayloadMarshaler, eventTypeFor func(Marshaler) (string, error), +) *EventWriter { + return &EventWriter{ + encoder: encoder, + payloadMarshaler: pm, + eventTypeFor: eventTypeFor, + } +} + +// WriteEvent writes an event to the stream. Returns an error if the event +// fails to marshal into a message, or writing to the underlying writer fails. +func (w *EventWriter) WriteEvent(event Marshaler) error { + msg, err := w.marshal(event) + if err != nil { + return err + } + + return w.encoder.Encode(msg) +} + +func (w *EventWriter) marshal(event Marshaler) (eventstream.Message, error) { + eventType, err := w.eventTypeFor(event) + if err != nil { + return eventstream.Message{}, err + } + + msg, err := event.MarshalEvent(w.payloadMarshaler) + if err != nil { + return eventstream.Message{}, err + } + + msg.Headers.Set(EventTypeHeader, eventstream.StringValue(eventType)) + return msg, nil +} + +//type EventEncoder struct { +// encoder Encoder +// ppayloadMarshaler protocol.PayloadMarshaler +// eventTypeFor func(Marshaler) (string, error) +//} +// +//func (e EventEncoder) Encode(event Marshaler) error { +// msg, err := e.marshal(event) +// if err != nil { +// return err +// } +// +// return w.encoder.Encode(msg) +//} +// +//func (e EventEncoder) marshal(event Marshaler) (eventstream.Message, error) { +// eventType, err := w.eventTypeFor(event) +// if err != nil { +// return eventstream.Message{}, err +// } +// +// msg, err := event.MarshalEvent(w.payloadMarshaler) +// if err != nil { +// return eventstream.Message{}, err +// } +// +// msg.Headers.Set(EventTypeHeader, eventstream.StringValue(eventType)) +// return msg, nil +//} +// +//func (w *EventWriter) marshal(event Marshaler) (eventstream.Message, error) { +// eventType, err := w.eventTypeFor(event) +// if err != nil { +// return eventstream.Message{}, err +// } +// +// msg, err := event.MarshalEvent(w.payloadMarshaler) +// if err != nil { +// return eventstream.Message{}, err +// } +// +// msg.Headers.Set(EventTypeHeader, eventstream.StringValue(eventType)) +// return msg, nil +//} +// diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.go new file mode 100644 index 00000000..f6f8c567 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.go @@ -0,0 +1,175 @@ +package eventstream + +import ( + "encoding/binary" + "fmt" + "io" +) + +// Headers are a collection of EventStream header values. +type Headers []Header + +// Header is a single EventStream Key Value header pair. +type Header struct { + Name string + Value Value +} + +// Set associates the name with a value. If the header name already exists in +// the Headers the value will be replaced with the new one. +func (hs *Headers) Set(name string, value Value) { + var i int + for ; i < len(*hs); i++ { + if (*hs)[i].Name == name { + (*hs)[i].Value = value + return + } + } + + *hs = append(*hs, Header{ + Name: name, Value: value, + }) +} + +// Get returns the Value associated with the header. Nil is returned if the +// value does not exist. +func (hs Headers) Get(name string) Value { + for i := 0; i < len(hs); i++ { + if h := hs[i]; h.Name == name { + return h.Value + } + } + return nil +} + +// Del deletes the value in the Headers if it exists. +func (hs *Headers) Del(name string) { + for i := 0; i < len(*hs); i++ { + if (*hs)[i].Name == name { + copy((*hs)[i:], (*hs)[i+1:]) + (*hs) = (*hs)[:len(*hs)-1] + } + } +} + +// Clone returns a deep copy of the headers +func (hs Headers) Clone() Headers { + o := make(Headers, 0, len(hs)) + for _, h := range hs { + o.Set(h.Name, h.Value) + } + return o +} + +func decodeHeaders(r io.Reader) (Headers, error) { + hs := Headers{} + + for { + name, err := decodeHeaderName(r) + if err != nil { + if err == io.EOF { + // EOF while getting header name means no more headers + break + } + return nil, err + } + + value, err := decodeHeaderValue(r) + if err != nil { + return nil, err + } + + hs.Set(name, value) + } + + return hs, nil +} + +func decodeHeaderName(r io.Reader) (string, error) { + var n headerName + + var err error + n.Len, err = decodeUint8(r) + if err != nil { + return "", err + } + + name := n.Name[:n.Len] + if _, err := io.ReadFull(r, name); err != nil { + return "", err + } + + return string(name), nil +} + +func decodeHeaderValue(r io.Reader) (Value, error) { + var raw rawValue + + typ, err := decodeUint8(r) + if err != nil { + return nil, err + } + raw.Type = valueType(typ) + + var v Value + + switch raw.Type { + case trueValueType: + v = BoolValue(true) + case falseValueType: + v = BoolValue(false) + case int8ValueType: + var tv Int8Value + err = tv.decode(r) + v = tv + case int16ValueType: + var tv Int16Value + err = tv.decode(r) + v = tv + case int32ValueType: + var tv Int32Value + err = tv.decode(r) + v = tv + case int64ValueType: + var tv Int64Value + err = tv.decode(r) + v = tv + case bytesValueType: + var tv BytesValue + err = tv.decode(r) + v = tv + case stringValueType: + var tv StringValue + err = tv.decode(r) + v = tv + case timestampValueType: + var tv TimestampValue + err = tv.decode(r) + v = tv + case uuidValueType: + var tv UUIDValue + err = tv.decode(r) + v = tv + default: + panic(fmt.Sprintf("unknown value type %d", raw.Type)) + } + + // Error could be EOF, let caller deal with it + return v, err +} + +const maxHeaderNameLen = 255 + +type headerName struct { + Len uint8 + Name [maxHeaderNameLen]byte +} + +func (v headerName) encode(w io.Writer) error { + if err := binary.Write(w, binary.BigEndian, v.Len); err != nil { + return err + } + + _, err := w.Write(v.Name[:v.Len]) + return err +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.go new file mode 100644 index 00000000..9f509d8f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.go @@ -0,0 +1,506 @@ +package eventstream + +import ( + "encoding/base64" + "encoding/binary" + "fmt" + "io" + "strconv" + "time" +) + +const maxHeaderValueLen = 1<<15 - 1 // 2^15-1 or 32KB - 1 + +// valueType is the EventStream header value type. +type valueType uint8 + +// Header value types +const ( + trueValueType valueType = iota + falseValueType + int8ValueType // Byte + int16ValueType // Short + int32ValueType // Integer + int64ValueType // Long + bytesValueType + stringValueType + timestampValueType + uuidValueType +) + +func (t valueType) String() string { + switch t { + case trueValueType: + return "bool" + case falseValueType: + return "bool" + case int8ValueType: + return "int8" + case int16ValueType: + return "int16" + case int32ValueType: + return "int32" + case int64ValueType: + return "int64" + case bytesValueType: + return "byte_array" + case stringValueType: + return "string" + case timestampValueType: + return "timestamp" + case uuidValueType: + return "uuid" + default: + return fmt.Sprintf("unknown value type %d", uint8(t)) + } +} + +type rawValue struct { + Type valueType + Len uint16 // Only set for variable length slices + Value []byte // byte representation of value, BigEndian encoding. +} + +func (r rawValue) encodeScalar(w io.Writer, v interface{}) error { + return binaryWriteFields(w, binary.BigEndian, + r.Type, + v, + ) +} + +func (r rawValue) encodeFixedSlice(w io.Writer, v []byte) error { + binary.Write(w, binary.BigEndian, r.Type) + + _, err := w.Write(v) + return err +} + +func (r rawValue) encodeBytes(w io.Writer, v []byte) error { + if len(v) > maxHeaderValueLen { + return LengthError{ + Part: "header value", + Want: maxHeaderValueLen, Have: len(v), + Value: v, + } + } + r.Len = uint16(len(v)) + + err := binaryWriteFields(w, binary.BigEndian, + r.Type, + r.Len, + ) + if err != nil { + return err + } + + _, err = w.Write(v) + return err +} + +func (r rawValue) encodeString(w io.Writer, v string) error { + if len(v) > maxHeaderValueLen { + return LengthError{ + Part: "header value", + Want: maxHeaderValueLen, Have: len(v), + Value: v, + } + } + r.Len = uint16(len(v)) + + type stringWriter interface { + WriteString(string) (int, error) + } + + err := binaryWriteFields(w, binary.BigEndian, + r.Type, + r.Len, + ) + if err != nil { + return err + } + + if sw, ok := w.(stringWriter); ok { + _, err = sw.WriteString(v) + } else { + _, err = w.Write([]byte(v)) + } + + return err +} + +func decodeFixedBytesValue(r io.Reader, buf []byte) error { + _, err := io.ReadFull(r, buf) + return err +} + +func decodeBytesValue(r io.Reader) ([]byte, error) { + var raw rawValue + var err error + raw.Len, err = decodeUint16(r) + if err != nil { + return nil, err + } + + buf := make([]byte, raw.Len) + _, err = io.ReadFull(r, buf) + if err != nil { + return nil, err + } + + return buf, nil +} + +func decodeStringValue(r io.Reader) (string, error) { + v, err := decodeBytesValue(r) + return string(v), err +} + +// Value represents the abstract header value. +type Value interface { + Get() interface{} + String() string + valueType() valueType + encode(io.Writer) error +} + +// An BoolValue provides eventstream encoding, and representation +// of a Go bool value. +type BoolValue bool + +// Get returns the underlying type +func (v BoolValue) Get() interface{} { + return bool(v) +} + +// valueType returns the EventStream header value type value. +func (v BoolValue) valueType() valueType { + if v { + return trueValueType + } + return falseValueType +} + +func (v BoolValue) String() string { + return strconv.FormatBool(bool(v)) +} + +// encode encodes the BoolValue into an eventstream binary value +// representation. +func (v BoolValue) encode(w io.Writer) error { + return binary.Write(w, binary.BigEndian, v.valueType()) +} + +// An Int8Value provides eventstream encoding, and representation of a Go +// int8 value. +type Int8Value int8 + +// Get returns the underlying value. +func (v Int8Value) Get() interface{} { + return int8(v) +} + +// valueType returns the EventStream header value type value. +func (Int8Value) valueType() valueType { + return int8ValueType +} + +func (v Int8Value) String() string { + return fmt.Sprintf("0x%02x", int8(v)) +} + +// encode encodes the Int8Value into an eventstream binary value +// representation. +func (v Int8Value) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + + return raw.encodeScalar(w, v) +} + +func (v *Int8Value) decode(r io.Reader) error { + n, err := decodeUint8(r) + if err != nil { + return err + } + + *v = Int8Value(n) + return nil +} + +// An Int16Value provides eventstream encoding, and representation of a Go +// int16 value. +type Int16Value int16 + +// Get returns the underlying value. +func (v Int16Value) Get() interface{} { + return int16(v) +} + +// valueType returns the EventStream header value type value. +func (Int16Value) valueType() valueType { + return int16ValueType +} + +func (v Int16Value) String() string { + return fmt.Sprintf("0x%04x", int16(v)) +} + +// encode encodes the Int16Value into an eventstream binary value +// representation. +func (v Int16Value) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + return raw.encodeScalar(w, v) +} + +func (v *Int16Value) decode(r io.Reader) error { + n, err := decodeUint16(r) + if err != nil { + return err + } + + *v = Int16Value(n) + return nil +} + +// An Int32Value provides eventstream encoding, and representation of a Go +// int32 value. +type Int32Value int32 + +// Get returns the underlying value. +func (v Int32Value) Get() interface{} { + return int32(v) +} + +// valueType returns the EventStream header value type value. +func (Int32Value) valueType() valueType { + return int32ValueType +} + +func (v Int32Value) String() string { + return fmt.Sprintf("0x%08x", int32(v)) +} + +// encode encodes the Int32Value into an eventstream binary value +// representation. +func (v Int32Value) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + return raw.encodeScalar(w, v) +} + +func (v *Int32Value) decode(r io.Reader) error { + n, err := decodeUint32(r) + if err != nil { + return err + } + + *v = Int32Value(n) + return nil +} + +// An Int64Value provides eventstream encoding, and representation of a Go +// int64 value. +type Int64Value int64 + +// Get returns the underlying value. +func (v Int64Value) Get() interface{} { + return int64(v) +} + +// valueType returns the EventStream header value type value. +func (Int64Value) valueType() valueType { + return int64ValueType +} + +func (v Int64Value) String() string { + return fmt.Sprintf("0x%016x", int64(v)) +} + +// encode encodes the Int64Value into an eventstream binary value +// representation. +func (v Int64Value) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + return raw.encodeScalar(w, v) +} + +func (v *Int64Value) decode(r io.Reader) error { + n, err := decodeUint64(r) + if err != nil { + return err + } + + *v = Int64Value(n) + return nil +} + +// An BytesValue provides eventstream encoding, and representation of a Go +// byte slice. +type BytesValue []byte + +// Get returns the underlying value. +func (v BytesValue) Get() interface{} { + return []byte(v) +} + +// valueType returns the EventStream header value type value. +func (BytesValue) valueType() valueType { + return bytesValueType +} + +func (v BytesValue) String() string { + return base64.StdEncoding.EncodeToString([]byte(v)) +} + +// encode encodes the BytesValue into an eventstream binary value +// representation. +func (v BytesValue) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + + return raw.encodeBytes(w, []byte(v)) +} + +func (v *BytesValue) decode(r io.Reader) error { + buf, err := decodeBytesValue(r) + if err != nil { + return err + } + + *v = BytesValue(buf) + return nil +} + +// An StringValue provides eventstream encoding, and representation of a Go +// string. +type StringValue string + +// Get returns the underlying value. +func (v StringValue) Get() interface{} { + return string(v) +} + +// valueType returns the EventStream header value type value. +func (StringValue) valueType() valueType { + return stringValueType +} + +func (v StringValue) String() string { + return string(v) +} + +// encode encodes the StringValue into an eventstream binary value +// representation. +func (v StringValue) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + + return raw.encodeString(w, string(v)) +} + +func (v *StringValue) decode(r io.Reader) error { + s, err := decodeStringValue(r) + if err != nil { + return err + } + + *v = StringValue(s) + return nil +} + +// An TimestampValue provides eventstream encoding, and representation of a Go +// timestamp. +type TimestampValue time.Time + +// Get returns the underlying value. +func (v TimestampValue) Get() interface{} { + return time.Time(v) +} + +// valueType returns the EventStream header value type value. +func (TimestampValue) valueType() valueType { + return timestampValueType +} + +func (v TimestampValue) epochMilli() int64 { + nano := time.Time(v).UnixNano() + msec := nano / int64(time.Millisecond) + return msec +} + +func (v TimestampValue) String() string { + msec := v.epochMilli() + return strconv.FormatInt(msec, 10) +} + +// encode encodes the TimestampValue into an eventstream binary value +// representation. +func (v TimestampValue) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + + msec := v.epochMilli() + return raw.encodeScalar(w, msec) +} + +func (v *TimestampValue) decode(r io.Reader) error { + n, err := decodeUint64(r) + if err != nil { + return err + } + + *v = TimestampValue(timeFromEpochMilli(int64(n))) + return nil +} + +// MarshalJSON implements the json.Marshaler interface +func (v TimestampValue) MarshalJSON() ([]byte, error) { + return []byte(v.String()), nil +} + +func timeFromEpochMilli(t int64) time.Time { + secs := t / 1e3 + msec := t % 1e3 + return time.Unix(secs, msec*int64(time.Millisecond)).UTC() +} + +// An UUIDValue provides eventstream encoding, and representation of a UUID +// value. +type UUIDValue [16]byte + +// Get returns the underlying value. +func (v UUIDValue) Get() interface{} { + return v[:] +} + +// valueType returns the EventStream header value type value. +func (UUIDValue) valueType() valueType { + return uuidValueType +} + +func (v UUIDValue) String() string { + return fmt.Sprintf(`%X-%X-%X-%X-%X`, v[0:4], v[4:6], v[6:8], v[8:10], v[10:]) +} + +// encode encodes the UUIDValue into an eventstream binary value +// representation. +func (v UUIDValue) encode(w io.Writer) error { + raw := rawValue{ + Type: v.valueType(), + } + + return raw.encodeFixedSlice(w, v[:]) +} + +func (v *UUIDValue) decode(r io.Reader) error { + tv := (*v)[:] + return decodeFixedBytesValue(r, tv) +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.go new file mode 100644 index 00000000..f7427da0 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.go @@ -0,0 +1,117 @@ +package eventstream + +import ( + "bytes" + "encoding/binary" + "hash/crc32" +) + +const preludeLen = 8 +const preludeCRCLen = 4 +const msgCRCLen = 4 +const minMsgLen = preludeLen + preludeCRCLen + msgCRCLen +const maxPayloadLen = 1024 * 1024 * 16 // 16MB +const maxHeadersLen = 1024 * 128 // 128KB +const maxMsgLen = minMsgLen + maxHeadersLen + maxPayloadLen + +var crc32IEEETable = crc32.MakeTable(crc32.IEEE) + +// A Message provides the eventstream message representation. +type Message struct { + Headers Headers + Payload []byte +} + +func (m *Message) rawMessage() (rawMessage, error) { + var raw rawMessage + + if len(m.Headers) > 0 { + var headers bytes.Buffer + if err := EncodeHeaders(&headers, m.Headers); err != nil { + return rawMessage{}, err + } + raw.Headers = headers.Bytes() + raw.HeadersLen = uint32(len(raw.Headers)) + } + + raw.Length = raw.HeadersLen + uint32(len(m.Payload)) + minMsgLen + + hash := crc32.New(crc32IEEETable) + binaryWriteFields(hash, binary.BigEndian, raw.Length, raw.HeadersLen) + raw.PreludeCRC = hash.Sum32() + + binaryWriteFields(hash, binary.BigEndian, raw.PreludeCRC) + + if raw.HeadersLen > 0 { + hash.Write(raw.Headers) + } + + // Read payload bytes and update hash for it as well. + if len(m.Payload) > 0 { + raw.Payload = m.Payload + hash.Write(raw.Payload) + } + + raw.CRC = hash.Sum32() + + return raw, nil +} + +// Clone returns a deep copy of the message. +func (m Message) Clone() Message { + var payload []byte + if m.Payload != nil { + payload = make([]byte, len(m.Payload)) + copy(payload, m.Payload) + } + + return Message{ + Headers: m.Headers.Clone(), + Payload: payload, + } +} + +type messagePrelude struct { + Length uint32 + HeadersLen uint32 + PreludeCRC uint32 +} + +func (p messagePrelude) PayloadLen() uint32 { + return p.Length - p.HeadersLen - minMsgLen +} + +func (p messagePrelude) ValidateLens() error { + if p.Length == 0 || p.Length > maxMsgLen { + return LengthError{ + Part: "message prelude", + Want: maxMsgLen, + Have: int(p.Length), + } + } + if p.HeadersLen > maxHeadersLen { + return LengthError{ + Part: "message headers", + Want: maxHeadersLen, + Have: int(p.HeadersLen), + } + } + if payloadLen := p.PayloadLen(); payloadLen > maxPayloadLen { + return LengthError{ + Part: "message payload", + Want: maxPayloadLen, + Have: int(payloadLen), + } + } + + return nil +} + +type rawMessage struct { + messagePrelude + + Headers []byte + Payload []byte + + CRC uint32 +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/jsonrpc.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/jsonrpc.go new file mode 100644 index 00000000..a029217e --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/jsonrpc.go @@ -0,0 +1,88 @@ +// Package jsonrpc provides JSON RPC utilities for serialization of AWS +// requests and responses. +package jsonrpc + +//go:generate go run -tags codegen ../../../private/model/cli/gen-protocol-tests ../../../models/protocol_tests/input/json.json build_test.go +//go:generate go run -tags codegen ../../../private/model/cli/gen-protocol-tests ../../../models/protocol_tests/output/json.json unmarshal_test.go + +import ( + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" + "github.com/aws/aws-sdk-go/private/protocol/rest" +) + +var emptyJSON = []byte("{}") + +// BuildHandler is a named request handler for building jsonrpc protocol +// requests +var BuildHandler = request.NamedHandler{ + Name: "awssdk.jsonrpc.Build", + Fn: Build, +} + +// UnmarshalHandler is a named request handler for unmarshaling jsonrpc +// protocol requests +var UnmarshalHandler = request.NamedHandler{ + Name: "awssdk.jsonrpc.Unmarshal", + Fn: Unmarshal, +} + +// UnmarshalMetaHandler is a named request handler for unmarshaling jsonrpc +// protocol request metadata +var UnmarshalMetaHandler = request.NamedHandler{ + Name: "awssdk.jsonrpc.UnmarshalMeta", + Fn: UnmarshalMeta, +} + +// Build builds a JSON payload for a JSON RPC request. +func Build(req *request.Request) { + var buf []byte + var err error + if req.ParamsFilled() { + buf, err = jsonutil.BuildJSON(req.Params) + if err != nil { + req.Error = awserr.New(request.ErrCodeSerialization, "failed encoding JSON RPC request", err) + return + } + } else { + buf = emptyJSON + } + + if req.ClientInfo.TargetPrefix != "" || string(buf) != "{}" { + req.SetBufferBody(buf) + } + + if req.ClientInfo.TargetPrefix != "" { + target := req.ClientInfo.TargetPrefix + "." + req.Operation.Name + req.HTTPRequest.Header.Add("X-Amz-Target", target) + } + + // Only set the content type if one is not already specified and an + // JSONVersion is specified. + if ct, v := req.HTTPRequest.Header.Get("Content-Type"), req.ClientInfo.JSONVersion; len(ct) == 0 && len(v) != 0 { + jsonVersion := req.ClientInfo.JSONVersion + req.HTTPRequest.Header.Set("Content-Type", "application/x-amz-json-"+jsonVersion) + } +} + +// Unmarshal unmarshals a response for a JSON RPC service. +func Unmarshal(req *request.Request) { + defer req.HTTPResponse.Body.Close() + if req.DataFilled() { + err := jsonutil.UnmarshalJSON(req.Data, req.HTTPResponse.Body) + if err != nil { + req.Error = awserr.NewRequestFailure( + awserr.New(request.ErrCodeSerialization, "failed decoding JSON RPC response", err), + req.HTTPResponse.StatusCode, + req.RequestID, + ) + } + } + return +} + +// UnmarshalMeta unmarshals headers from a response for a JSON RPC service. +func UnmarshalMeta(req *request.Request) { + rest.UnmarshalMeta(req) +} diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/unmarshal_error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/unmarshal_error.go new file mode 100644 index 00000000..c0c52e2d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/unmarshal_error.go @@ -0,0 +1,107 @@ +package jsonrpc + +import ( + "bytes" + "io" + "io/ioutil" + "net/http" + "strings" + + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/private/protocol" + "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" +) + +// UnmarshalTypedError provides unmarshaling errors API response errors +// for both typed and untyped errors. +type UnmarshalTypedError struct { + exceptions map[string]func(protocol.ResponseMetadata) error +} + +// NewUnmarshalTypedError returns an UnmarshalTypedError initialized for the +// set of exception names to the error unmarshalers +func NewUnmarshalTypedError(exceptions map[string]func(protocol.ResponseMetadata) error) *UnmarshalTypedError { + return &UnmarshalTypedError{ + exceptions: exceptions, + } +} + +// UnmarshalError attempts to unmarshal the HTTP response error as a known +// error type. If unable to unmarshal the error type, the generic SDK error +// type will be used. +func (u *UnmarshalTypedError) UnmarshalError( + resp *http.Response, + respMeta protocol.ResponseMetadata, +) (error, error) { + + var buf bytes.Buffer + var jsonErr jsonErrorResponse + teeReader := io.TeeReader(resp.Body, &buf) + err := jsonutil.UnmarshalJSONError(&jsonErr, teeReader) + if err != nil { + return nil, err + } + body := ioutil.NopCloser(&buf) + + // Code may be separated by hash(#), with the last element being the code + // used by the SDK. + codeParts := strings.SplitN(jsonErr.Code, "#", 2) + code := codeParts[len(codeParts)-1] + msg := jsonErr.Message + + if fn, ok := u.exceptions[code]; ok { + // If exception code is know, use associated constructor to get a value + // for the exception that the JSON body can be unmarshaled into. + v := fn(respMeta) + err := jsonutil.UnmarshalJSONCaseInsensitive(v, body) + if err != nil { + return nil, err + } + + return v, nil + } + + // fallback to unmodeled generic exceptions + return awserr.NewRequestFailure( + awserr.New(code, msg, nil), + respMeta.StatusCode, + respMeta.RequestID, + ), nil +} + +// UnmarshalErrorHandler is a named request handler for unmarshaling jsonrpc +// protocol request errors +var UnmarshalErrorHandler = request.NamedHandler{ + Name: "awssdk.jsonrpc.UnmarshalError", + Fn: UnmarshalError, +} + +// UnmarshalError unmarshals an error response for a JSON RPC service. +func UnmarshalError(req *request.Request) { + defer req.HTTPResponse.Body.Close() + + var jsonErr jsonErrorResponse + err := jsonutil.UnmarshalJSONError(&jsonErr, req.HTTPResponse.Body) + if err != nil { + req.Error = awserr.NewRequestFailure( + awserr.New(request.ErrCodeSerialization, + "failed to unmarshal error message", err), + req.HTTPResponse.StatusCode, + req.RequestID, + ) + return + } + + codes := strings.SplitN(jsonErr.Code, "#", 2) + req.Error = awserr.NewRequestFailure( + awserr.New(codes[len(codes)-1], jsonErr.Message, nil), + req.HTTPResponse.StatusCode, + req.RequestID, + ) +} + +type jsonErrorResponse struct { + Code string `json:"__type"` + Message string `json:"message"` +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/kinesis/api.go b/vendor/github.com/aws/aws-sdk-go/service/kinesis/api.go new file mode 100644 index 00000000..4a24daca --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/kinesis/api.go @@ -0,0 +1,8986 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package kinesis + +import ( + "bytes" + "fmt" + "io" + "sync" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/awsutil" + "github.com/aws/aws-sdk-go/aws/client" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/private/protocol" + "github.com/aws/aws-sdk-go/private/protocol/eventstream" + "github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi" + "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" + "github.com/aws/aws-sdk-go/private/protocol/rest" +) + +const opAddTagsToStream = "AddTagsToStream" + +// AddTagsToStreamRequest generates a "aws/request.Request" representing the +// client's request for the AddTagsToStream operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See AddTagsToStream for more information on using the AddTagsToStream +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the AddTagsToStreamRequest method. +// req, resp := client.AddTagsToStreamRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/AddTagsToStream +func (c *Kinesis) AddTagsToStreamRequest(input *AddTagsToStreamInput) (req *request.Request, output *AddTagsToStreamOutput) { + op := &request.Operation{ + Name: opAddTagsToStream, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &AddTagsToStreamInput{} + } + + output = &AddTagsToStreamOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// AddTagsToStream API operation for Amazon Kinesis. +// +// Adds or updates tags for the specified Kinesis data stream. Each time you +// invoke this operation, you can specify up to 10 tags. If you want to add +// more than 10 tags to your stream, you can invoke this operation multiple +// times. In total, each stream can have up to 50 tags. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation AddTagsToStream for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/AddTagsToStream +func (c *Kinesis) AddTagsToStream(input *AddTagsToStreamInput) (*AddTagsToStreamOutput, error) { + req, out := c.AddTagsToStreamRequest(input) + return out, req.Send() +} + +// AddTagsToStreamWithContext is the same as AddTagsToStream with the addition of +// the ability to pass a context and additional request options. +// +// See AddTagsToStream for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) AddTagsToStreamWithContext(ctx aws.Context, input *AddTagsToStreamInput, opts ...request.Option) (*AddTagsToStreamOutput, error) { + req, out := c.AddTagsToStreamRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opCreateStream = "CreateStream" + +// CreateStreamRequest generates a "aws/request.Request" representing the +// client's request for the CreateStream operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See CreateStream for more information on using the CreateStream +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the CreateStreamRequest method. +// req, resp := client.CreateStreamRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/CreateStream +func (c *Kinesis) CreateStreamRequest(input *CreateStreamInput) (req *request.Request, output *CreateStreamOutput) { + op := &request.Operation{ + Name: opCreateStream, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &CreateStreamInput{} + } + + output = &CreateStreamOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// CreateStream API operation for Amazon Kinesis. +// +// 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 specify and control the number of shards that a stream is composed of. +// 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 AWS account +// used by the application. It is also scoped by AWS 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: +// +// * Have more than five streams in the CREATING state at any point in time. +// +// * Create more shards than are authorized for your account. +// +// For the default shard limit for an AWS account, see Amazon Kinesis Data Streams +// Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// in the Amazon Kinesis Data Streams Developer Guide. To increase this limit, +// contact AWS Support (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html). +// +// You can use DescribeStream to check the stream status, which is returned +// in StreamStatus. +// +// CreateStream has a limit of five transactions per second per account. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation CreateStream for usage and error information. +// +// Returned Error Types: +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/CreateStream +func (c *Kinesis) CreateStream(input *CreateStreamInput) (*CreateStreamOutput, error) { + req, out := c.CreateStreamRequest(input) + return out, req.Send() +} + +// CreateStreamWithContext is the same as CreateStream with the addition of +// the ability to pass a context and additional request options. +// +// See CreateStream for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) CreateStreamWithContext(ctx aws.Context, input *CreateStreamInput, opts ...request.Option) (*CreateStreamOutput, error) { + req, out := c.CreateStreamRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opDecreaseStreamRetentionPeriod = "DecreaseStreamRetentionPeriod" + +// DecreaseStreamRetentionPeriodRequest generates a "aws/request.Request" representing the +// client's request for the DecreaseStreamRetentionPeriod operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DecreaseStreamRetentionPeriod for more information on using the DecreaseStreamRetentionPeriod +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DecreaseStreamRetentionPeriodRequest method. +// req, resp := client.DecreaseStreamRetentionPeriodRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DecreaseStreamRetentionPeriod +func (c *Kinesis) DecreaseStreamRetentionPeriodRequest(input *DecreaseStreamRetentionPeriodInput) (req *request.Request, output *DecreaseStreamRetentionPeriodOutput) { + op := &request.Operation{ + Name: opDecreaseStreamRetentionPeriod, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DecreaseStreamRetentionPeriodInput{} + } + + output = &DecreaseStreamRetentionPeriodOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// DecreaseStreamRetentionPeriod API operation for Amazon Kinesis. +// +// 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. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DecreaseStreamRetentionPeriod for usage and error information. +// +// Returned Error Types: +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DecreaseStreamRetentionPeriod +func (c *Kinesis) DecreaseStreamRetentionPeriod(input *DecreaseStreamRetentionPeriodInput) (*DecreaseStreamRetentionPeriodOutput, error) { + req, out := c.DecreaseStreamRetentionPeriodRequest(input) + return out, req.Send() +} + +// DecreaseStreamRetentionPeriodWithContext is the same as DecreaseStreamRetentionPeriod with the addition of +// the ability to pass a context and additional request options. +// +// See DecreaseStreamRetentionPeriod for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DecreaseStreamRetentionPeriodWithContext(ctx aws.Context, input *DecreaseStreamRetentionPeriodInput, opts ...request.Option) (*DecreaseStreamRetentionPeriodOutput, error) { + req, out := c.DecreaseStreamRetentionPeriodRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opDeleteStream = "DeleteStream" + +// DeleteStreamRequest generates a "aws/request.Request" representing the +// client's request for the DeleteStream operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DeleteStream for more information on using the DeleteStream +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DeleteStreamRequest method. +// req, resp := client.DeleteStreamRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DeleteStream +func (c *Kinesis) DeleteStreamRequest(input *DeleteStreamInput) (req *request.Request, output *DeleteStreamOutput) { + op := &request.Operation{ + Name: opDeleteStream, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DeleteStreamInput{} + } + + output = &DeleteStreamOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// DeleteStream API operation for Amazon Kinesis. +// +// 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. +// +// 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 DescribeStream operation to check the state of the stream, +// which is returned in StreamStatus. +// +// DeleteStream has a limit of five transactions per second per account. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DeleteStream for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DeleteStream +func (c *Kinesis) DeleteStream(input *DeleteStreamInput) (*DeleteStreamOutput, error) { + req, out := c.DeleteStreamRequest(input) + return out, req.Send() +} + +// DeleteStreamWithContext is the same as DeleteStream with the addition of +// the ability to pass a context and additional request options. +// +// See DeleteStream for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DeleteStreamWithContext(ctx aws.Context, input *DeleteStreamInput, opts ...request.Option) (*DeleteStreamOutput, error) { + req, out := c.DeleteStreamRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opDeregisterStreamConsumer = "DeregisterStreamConsumer" + +// DeregisterStreamConsumerRequest generates a "aws/request.Request" representing the +// client's request for the DeregisterStreamConsumer operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DeregisterStreamConsumer for more information on using the DeregisterStreamConsumer +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DeregisterStreamConsumerRequest method. +// req, resp := client.DeregisterStreamConsumerRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DeregisterStreamConsumer +func (c *Kinesis) DeregisterStreamConsumerRequest(input *DeregisterStreamConsumerInput) (req *request.Request, output *DeregisterStreamConsumerOutput) { + op := &request.Operation{ + Name: opDeregisterStreamConsumer, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DeregisterStreamConsumerInput{} + } + + output = &DeregisterStreamConsumerOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// DeregisterStreamConsumer API operation for Amazon Kinesis. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DeregisterStreamConsumer for usage and error information. +// +// Returned Error Types: +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DeregisterStreamConsumer +func (c *Kinesis) DeregisterStreamConsumer(input *DeregisterStreamConsumerInput) (*DeregisterStreamConsumerOutput, error) { + req, out := c.DeregisterStreamConsumerRequest(input) + return out, req.Send() +} + +// DeregisterStreamConsumerWithContext is the same as DeregisterStreamConsumer with the addition of +// the ability to pass a context and additional request options. +// +// See DeregisterStreamConsumer for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DeregisterStreamConsumerWithContext(ctx aws.Context, input *DeregisterStreamConsumerInput, opts ...request.Option) (*DeregisterStreamConsumerOutput, error) { + req, out := c.DeregisterStreamConsumerRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opDescribeLimits = "DescribeLimits" + +// DescribeLimitsRequest generates a "aws/request.Request" representing the +// client's request for the DescribeLimits operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DescribeLimits for more information on using the DescribeLimits +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DescribeLimitsRequest method. +// req, resp := client.DescribeLimitsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeLimits +func (c *Kinesis) DescribeLimitsRequest(input *DescribeLimitsInput) (req *request.Request, output *DescribeLimitsOutput) { + op := &request.Operation{ + Name: opDescribeLimits, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeLimitsInput{} + } + + output = &DescribeLimitsOutput{} + req = c.newRequest(op, input, output) + return +} + +// DescribeLimits API operation for Amazon Kinesis. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DescribeLimits for usage and error information. +// +// Returned Error Types: +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeLimits +func (c *Kinesis) DescribeLimits(input *DescribeLimitsInput) (*DescribeLimitsOutput, error) { + req, out := c.DescribeLimitsRequest(input) + return out, req.Send() +} + +// DescribeLimitsWithContext is the same as DescribeLimits with the addition of +// the ability to pass a context and additional request options. +// +// See DescribeLimits for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DescribeLimitsWithContext(ctx aws.Context, input *DescribeLimitsInput, opts ...request.Option) (*DescribeLimitsOutput, error) { + req, out := c.DescribeLimitsRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opDescribeStream = "DescribeStream" + +// DescribeStreamRequest generates a "aws/request.Request" representing the +// client's request for the DescribeStream operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DescribeStream for more information on using the DescribeStream +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DescribeStreamRequest method. +// req, resp := client.DescribeStreamRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeStream +func (c *Kinesis) DescribeStreamRequest(input *DescribeStreamInput) (req *request.Request, output *DescribeStreamOutput) { + op := &request.Operation{ + Name: opDescribeStream, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"ExclusiveStartShardId"}, + OutputTokens: []string{"StreamDescription.Shards[-1].ShardId"}, + LimitToken: "Limit", + TruncationToken: "StreamDescription.HasMoreShards", + }, + } + + if input == nil { + input = &DescribeStreamInput{} + } + + output = &DescribeStreamOutput{} + req = c.newRequest(op, input, output) + return +} + +// DescribeStream API operation for Amazon Kinesis. +// +// Describes the specified Kinesis data stream. +// +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-retrieve-shards.html) +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DescribeStream for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeStream +func (c *Kinesis) DescribeStream(input *DescribeStreamInput) (*DescribeStreamOutput, error) { + req, out := c.DescribeStreamRequest(input) + return out, req.Send() +} + +// DescribeStreamWithContext is the same as DescribeStream with the addition of +// the ability to pass a context and additional request options. +// +// See DescribeStream for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DescribeStreamWithContext(ctx aws.Context, input *DescribeStreamInput, opts ...request.Option) (*DescribeStreamOutput, error) { + req, out := c.DescribeStreamRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +// DescribeStreamPages iterates over the pages of a DescribeStream operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See DescribeStream method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a DescribeStream operation. +// pageNum := 0 +// err := client.DescribeStreamPages(params, +// func(page *kinesis.DescribeStreamOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Kinesis) DescribeStreamPages(input *DescribeStreamInput, fn func(*DescribeStreamOutput, bool) bool) error { + return c.DescribeStreamPagesWithContext(aws.BackgroundContext(), input, fn) +} + +// DescribeStreamPagesWithContext same as DescribeStreamPages except +// it takes a Context and allows setting request options on the pages. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DescribeStreamPagesWithContext(ctx aws.Context, input *DescribeStreamInput, fn func(*DescribeStreamOutput, bool) bool, opts ...request.Option) error { + p := request.Pagination{ + NewRequest: func() (*request.Request, error) { + var inCpy *DescribeStreamInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.DescribeStreamRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + + for p.Next() { + if !fn(p.Page().(*DescribeStreamOutput), !p.HasNextPage()) { + break + } + } + + return p.Err() +} + +const opDescribeStreamConsumer = "DescribeStreamConsumer" + +// DescribeStreamConsumerRequest generates a "aws/request.Request" representing the +// client's request for the DescribeStreamConsumer operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DescribeStreamConsumer for more information on using the DescribeStreamConsumer +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DescribeStreamConsumerRequest method. +// req, resp := client.DescribeStreamConsumerRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeStreamConsumer +func (c *Kinesis) DescribeStreamConsumerRequest(input *DescribeStreamConsumerInput) (req *request.Request, output *DescribeStreamConsumerOutput) { + op := &request.Operation{ + Name: opDescribeStreamConsumer, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeStreamConsumerInput{} + } + + output = &DescribeStreamConsumerOutput{} + req = c.newRequest(op, input, output) + return +} + +// DescribeStreamConsumer API operation for Amazon Kinesis. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DescribeStreamConsumer for usage and error information. +// +// Returned Error Types: +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeStreamConsumer +func (c *Kinesis) DescribeStreamConsumer(input *DescribeStreamConsumerInput) (*DescribeStreamConsumerOutput, error) { + req, out := c.DescribeStreamConsumerRequest(input) + return out, req.Send() +} + +// DescribeStreamConsumerWithContext is the same as DescribeStreamConsumer with the addition of +// the ability to pass a context and additional request options. +// +// See DescribeStreamConsumer for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DescribeStreamConsumerWithContext(ctx aws.Context, input *DescribeStreamConsumerInput, opts ...request.Option) (*DescribeStreamConsumerOutput, error) { + req, out := c.DescribeStreamConsumerRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opDescribeStreamSummary = "DescribeStreamSummary" + +// DescribeStreamSummaryRequest generates a "aws/request.Request" representing the +// client's request for the DescribeStreamSummary operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DescribeStreamSummary for more information on using the DescribeStreamSummary +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DescribeStreamSummaryRequest method. +// req, resp := client.DescribeStreamSummaryRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeStreamSummary +func (c *Kinesis) DescribeStreamSummaryRequest(input *DescribeStreamSummaryInput) (req *request.Request, output *DescribeStreamSummaryOutput) { + op := &request.Operation{ + Name: opDescribeStreamSummary, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DescribeStreamSummaryInput{} + } + + output = &DescribeStreamSummaryOutput{} + req = c.newRequest(op, input, output) + return +} + +// DescribeStreamSummary API operation for Amazon Kinesis. +// +// Provides a summarized description of the specified Kinesis data stream without +// the shard list. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DescribeStreamSummary for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeStreamSummary +func (c *Kinesis) DescribeStreamSummary(input *DescribeStreamSummaryInput) (*DescribeStreamSummaryOutput, error) { + req, out := c.DescribeStreamSummaryRequest(input) + return out, req.Send() +} + +// DescribeStreamSummaryWithContext is the same as DescribeStreamSummary with the addition of +// the ability to pass a context and additional request options. +// +// See DescribeStreamSummary for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DescribeStreamSummaryWithContext(ctx aws.Context, input *DescribeStreamSummaryInput, opts ...request.Option) (*DescribeStreamSummaryOutput, error) { + req, out := c.DescribeStreamSummaryRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opDisableEnhancedMonitoring = "DisableEnhancedMonitoring" + +// DisableEnhancedMonitoringRequest generates a "aws/request.Request" representing the +// client's request for the DisableEnhancedMonitoring operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DisableEnhancedMonitoring for more information on using the DisableEnhancedMonitoring +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DisableEnhancedMonitoringRequest method. +// req, resp := client.DisableEnhancedMonitoringRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DisableEnhancedMonitoring +func (c *Kinesis) DisableEnhancedMonitoringRequest(input *DisableEnhancedMonitoringInput) (req *request.Request, output *EnhancedMonitoringOutput) { + op := &request.Operation{ + Name: opDisableEnhancedMonitoring, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &DisableEnhancedMonitoringInput{} + } + + output = &EnhancedMonitoringOutput{} + req = c.newRequest(op, input, output) + return +} + +// DisableEnhancedMonitoring API operation for Amazon Kinesis. +// +// Disables enhanced monitoring. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation DisableEnhancedMonitoring for usage and error information. +// +// Returned Error Types: +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DisableEnhancedMonitoring +func (c *Kinesis) DisableEnhancedMonitoring(input *DisableEnhancedMonitoringInput) (*EnhancedMonitoringOutput, error) { + req, out := c.DisableEnhancedMonitoringRequest(input) + return out, req.Send() +} + +// DisableEnhancedMonitoringWithContext is the same as DisableEnhancedMonitoring with the addition of +// the ability to pass a context and additional request options. +// +// See DisableEnhancedMonitoring for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) DisableEnhancedMonitoringWithContext(ctx aws.Context, input *DisableEnhancedMonitoringInput, opts ...request.Option) (*EnhancedMonitoringOutput, error) { + req, out := c.DisableEnhancedMonitoringRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opEnableEnhancedMonitoring = "EnableEnhancedMonitoring" + +// EnableEnhancedMonitoringRequest generates a "aws/request.Request" representing the +// client's request for the EnableEnhancedMonitoring operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See EnableEnhancedMonitoring for more information on using the EnableEnhancedMonitoring +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the EnableEnhancedMonitoringRequest method. +// req, resp := client.EnableEnhancedMonitoringRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/EnableEnhancedMonitoring +func (c *Kinesis) EnableEnhancedMonitoringRequest(input *EnableEnhancedMonitoringInput) (req *request.Request, output *EnhancedMonitoringOutput) { + op := &request.Operation{ + Name: opEnableEnhancedMonitoring, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &EnableEnhancedMonitoringInput{} + } + + output = &EnhancedMonitoringOutput{} + req = c.newRequest(op, input, output) + return +} + +// EnableEnhancedMonitoring API operation for Amazon Kinesis. +// +// Enables enhanced Kinesis data stream monitoring for shard-level metrics. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation EnableEnhancedMonitoring for usage and error information. +// +// Returned Error Types: +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/EnableEnhancedMonitoring +func (c *Kinesis) EnableEnhancedMonitoring(input *EnableEnhancedMonitoringInput) (*EnhancedMonitoringOutput, error) { + req, out := c.EnableEnhancedMonitoringRequest(input) + return out, req.Send() +} + +// EnableEnhancedMonitoringWithContext is the same as EnableEnhancedMonitoring with the addition of +// the ability to pass a context and additional request options. +// +// See EnableEnhancedMonitoring for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) EnableEnhancedMonitoringWithContext(ctx aws.Context, input *EnableEnhancedMonitoringInput, opts ...request.Option) (*EnhancedMonitoringOutput, error) { + req, out := c.EnableEnhancedMonitoringRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opGetRecords = "GetRecords" + +// GetRecordsRequest generates a "aws/request.Request" representing the +// client's request for the GetRecords operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See GetRecords for more information on using the GetRecords +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the GetRecordsRequest method. +// req, resp := client.GetRecordsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/GetRecords +func (c *Kinesis) GetRecordsRequest(input *GetRecordsInput) (req *request.Request, output *GetRecordsOutput) { + op := &request.Operation{ + Name: opGetRecords, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &GetRecordsInput{} + } + + output = &GetRecordsOutput{} + req = c.newRequest(op, input, output) + return +} + +// GetRecords API operation for Amazon Kinesis. +// +// Gets data records from a Kinesis data stream's shard. +// +// 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 +// (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// 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. 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 (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring.html) +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation GetRecords for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * ProvisionedThroughputExceededException +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and +// Exponential Backoff in AWS (https://docs.aws.amazon.com/general/latest/gr/api-retries.html) +// in the AWS General Reference. +// +// * ExpiredIteratorException +// The provided iterator exceeds the maximum age allowed. +// +// * KMSDisabledException +// The request was rejected because the specified customer master key (CMK) +// isn't enabled. +// +// * KMSInvalidStateException +// 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 (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html) +// in the AWS Key Management Service Developer Guide. +// +// * KMSAccessDeniedException +// The ciphertext references a key that doesn't exist or that you don't have +// access to. +// +// * KMSNotFoundException +// The request was rejected because the specified entity or resource can't be +// found. +// +// * KMSOptInRequired +// The AWS access key ID needs a subscription for the service. +// +// * KMSThrottlingException +// The request was denied due to request throttling. For more information about +// throttling, see Limits (https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) +// in the AWS Key Management Service Developer Guide. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/GetRecords +func (c *Kinesis) GetRecords(input *GetRecordsInput) (*GetRecordsOutput, error) { + req, out := c.GetRecordsRequest(input) + return out, req.Send() +} + +// GetRecordsWithContext is the same as GetRecords with the addition of +// the ability to pass a context and additional request options. +// +// See GetRecords for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) GetRecordsWithContext(ctx aws.Context, input *GetRecordsInput, opts ...request.Option) (*GetRecordsOutput, error) { + req, out := c.GetRecordsRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opGetShardIterator = "GetShardIterator" + +// GetShardIteratorRequest generates a "aws/request.Request" representing the +// client's request for the GetShardIterator operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See GetShardIterator for more information on using the GetShardIterator +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the GetShardIteratorRequest method. +// req, resp := client.GetShardIteratorRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/GetShardIterator +func (c *Kinesis) GetShardIteratorRequest(input *GetShardIteratorInput) (req *request.Request, output *GetShardIteratorOutput) { + op := &request.Operation{ + Name: opGetShardIterator, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &GetShardIteratorInput{} + } + + output = &GetShardIteratorOutput{} + req = c.newRequest(op, input, output) + return +} + +// GetShardIterator API operation for Amazon Kinesis. +// +// Gets an Amazon Kinesis shard iterator. A shard iterator expires 5 minutes +// after it is returned to the requester. +// +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation GetShardIterator for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * ProvisionedThroughputExceededException +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and +// Exponential Backoff in AWS (https://docs.aws.amazon.com/general/latest/gr/api-retries.html) +// in the AWS General Reference. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/GetShardIterator +func (c *Kinesis) GetShardIterator(input *GetShardIteratorInput) (*GetShardIteratorOutput, error) { + req, out := c.GetShardIteratorRequest(input) + return out, req.Send() +} + +// GetShardIteratorWithContext is the same as GetShardIterator with the addition of +// the ability to pass a context and additional request options. +// +// See GetShardIterator for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) GetShardIteratorWithContext(ctx aws.Context, input *GetShardIteratorInput, opts ...request.Option) (*GetShardIteratorOutput, error) { + req, out := c.GetShardIteratorRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opIncreaseStreamRetentionPeriod = "IncreaseStreamRetentionPeriod" + +// IncreaseStreamRetentionPeriodRequest generates a "aws/request.Request" representing the +// client's request for the IncreaseStreamRetentionPeriod operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See IncreaseStreamRetentionPeriod for more information on using the IncreaseStreamRetentionPeriod +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the IncreaseStreamRetentionPeriodRequest method. +// req, resp := client.IncreaseStreamRetentionPeriodRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/IncreaseStreamRetentionPeriod +func (c *Kinesis) IncreaseStreamRetentionPeriodRequest(input *IncreaseStreamRetentionPeriodInput) (req *request.Request, output *IncreaseStreamRetentionPeriodOutput) { + op := &request.Operation{ + Name: opIncreaseStreamRetentionPeriod, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &IncreaseStreamRetentionPeriodInput{} + } + + output = &IncreaseStreamRetentionPeriodOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// IncreaseStreamRetentionPeriod API operation for Amazon Kinesis. +// +// 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 168 hours (7 days). +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation IncreaseStreamRetentionPeriod for usage and error information. +// +// Returned Error Types: +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/IncreaseStreamRetentionPeriod +func (c *Kinesis) IncreaseStreamRetentionPeriod(input *IncreaseStreamRetentionPeriodInput) (*IncreaseStreamRetentionPeriodOutput, error) { + req, out := c.IncreaseStreamRetentionPeriodRequest(input) + return out, req.Send() +} + +// IncreaseStreamRetentionPeriodWithContext is the same as IncreaseStreamRetentionPeriod with the addition of +// the ability to pass a context and additional request options. +// +// See IncreaseStreamRetentionPeriod for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) IncreaseStreamRetentionPeriodWithContext(ctx aws.Context, input *IncreaseStreamRetentionPeriodInput, opts ...request.Option) (*IncreaseStreamRetentionPeriodOutput, error) { + req, out := c.IncreaseStreamRetentionPeriodRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opListShards = "ListShards" + +// ListShardsRequest generates a "aws/request.Request" representing the +// client's request for the ListShards operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See ListShards for more information on using the ListShards +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the ListShardsRequest method. +// req, resp := client.ListShardsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListShards +func (c *Kinesis) ListShardsRequest(input *ListShardsInput) (req *request.Request, output *ListShardsOutput) { + op := &request.Operation{ + Name: opListShards, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ListShardsInput{} + } + + output = &ListShardsOutput{} + req = c.newRequest(op, input, output) + return +} + +// ListShards API operation for Amazon Kinesis. +// +// Lists the shards in a stream and provides information about each shard. This +// operation has a limit of 100 transactions per second per data stream. +// +// 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 +// (https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html). +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation ListShards for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ExpiredNextTokenException +// The pagination token passed to the operation is expired. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListShards +func (c *Kinesis) ListShards(input *ListShardsInput) (*ListShardsOutput, error) { + req, out := c.ListShardsRequest(input) + return out, req.Send() +} + +// ListShardsWithContext is the same as ListShards with the addition of +// the ability to pass a context and additional request options. +// +// See ListShards for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) ListShardsWithContext(ctx aws.Context, input *ListShardsInput, opts ...request.Option) (*ListShardsOutput, error) { + req, out := c.ListShardsRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opListStreamConsumers = "ListStreamConsumers" + +// ListStreamConsumersRequest generates a "aws/request.Request" representing the +// client's request for the ListStreamConsumers operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See ListStreamConsumers for more information on using the ListStreamConsumers +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the ListStreamConsumersRequest method. +// req, resp := client.ListStreamConsumersRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListStreamConsumers +func (c *Kinesis) ListStreamConsumersRequest(input *ListStreamConsumersInput) (req *request.Request, output *ListStreamConsumersOutput) { + op := &request.Operation{ + Name: opListStreamConsumers, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"NextToken"}, + OutputTokens: []string{"NextToken"}, + LimitToken: "MaxResults", + TruncationToken: "", + }, + } + + if input == nil { + input = &ListStreamConsumersInput{} + } + + output = &ListStreamConsumersOutput{} + req = c.newRequest(op, input, output) + return +} + +// ListStreamConsumers API operation for Amazon Kinesis. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation ListStreamConsumers for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ExpiredNextTokenException +// The pagination token passed to the operation is expired. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListStreamConsumers +func (c *Kinesis) ListStreamConsumers(input *ListStreamConsumersInput) (*ListStreamConsumersOutput, error) { + req, out := c.ListStreamConsumersRequest(input) + return out, req.Send() +} + +// ListStreamConsumersWithContext is the same as ListStreamConsumers with the addition of +// the ability to pass a context and additional request options. +// +// See ListStreamConsumers for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) ListStreamConsumersWithContext(ctx aws.Context, input *ListStreamConsumersInput, opts ...request.Option) (*ListStreamConsumersOutput, error) { + req, out := c.ListStreamConsumersRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +// ListStreamConsumersPages iterates over the pages of a ListStreamConsumers operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See ListStreamConsumers method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a ListStreamConsumers operation. +// pageNum := 0 +// err := client.ListStreamConsumersPages(params, +// func(page *kinesis.ListStreamConsumersOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Kinesis) ListStreamConsumersPages(input *ListStreamConsumersInput, fn func(*ListStreamConsumersOutput, bool) bool) error { + return c.ListStreamConsumersPagesWithContext(aws.BackgroundContext(), input, fn) +} + +// ListStreamConsumersPagesWithContext same as ListStreamConsumersPages except +// it takes a Context and allows setting request options on the pages. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) ListStreamConsumersPagesWithContext(ctx aws.Context, input *ListStreamConsumersInput, fn func(*ListStreamConsumersOutput, bool) bool, opts ...request.Option) error { + p := request.Pagination{ + NewRequest: func() (*request.Request, error) { + var inCpy *ListStreamConsumersInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.ListStreamConsumersRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + + for p.Next() { + if !fn(p.Page().(*ListStreamConsumersOutput), !p.HasNextPage()) { + break + } + } + + return p.Err() +} + +const opListStreams = "ListStreams" + +// ListStreamsRequest generates a "aws/request.Request" representing the +// client's request for the ListStreams operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See ListStreams for more information on using the ListStreams +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the ListStreamsRequest method. +// req, resp := client.ListStreamsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListStreams +func (c *Kinesis) ListStreamsRequest(input *ListStreamsInput) (req *request.Request, output *ListStreamsOutput) { + op := &request.Operation{ + Name: opListStreams, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"ExclusiveStartStreamName"}, + OutputTokens: []string{"StreamNames[-1]"}, + LimitToken: "Limit", + TruncationToken: "HasMoreStreams", + }, + } + + if input == nil { + input = &ListStreamsInput{} + } + + output = &ListStreamsOutput{} + req = c.newRequest(op, input, output) + return +} + +// ListStreams API operation for Amazon Kinesis. +// +// 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 10. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation ListStreams for usage and error information. +// +// Returned Error Types: +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListStreams +func (c *Kinesis) ListStreams(input *ListStreamsInput) (*ListStreamsOutput, error) { + req, out := c.ListStreamsRequest(input) + return out, req.Send() +} + +// ListStreamsWithContext is the same as ListStreams with the addition of +// the ability to pass a context and additional request options. +// +// See ListStreams for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) ListStreamsWithContext(ctx aws.Context, input *ListStreamsInput, opts ...request.Option) (*ListStreamsOutput, error) { + req, out := c.ListStreamsRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +// ListStreamsPages iterates over the pages of a ListStreams operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See ListStreams method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a ListStreams operation. +// pageNum := 0 +// err := client.ListStreamsPages(params, +// func(page *kinesis.ListStreamsOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Kinesis) ListStreamsPages(input *ListStreamsInput, fn func(*ListStreamsOutput, bool) bool) error { + return c.ListStreamsPagesWithContext(aws.BackgroundContext(), input, fn) +} + +// ListStreamsPagesWithContext same as ListStreamsPages except +// it takes a Context and allows setting request options on the pages. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) ListStreamsPagesWithContext(ctx aws.Context, input *ListStreamsInput, fn func(*ListStreamsOutput, bool) bool, opts ...request.Option) error { + p := request.Pagination{ + NewRequest: func() (*request.Request, error) { + var inCpy *ListStreamsInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.ListStreamsRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + + for p.Next() { + if !fn(p.Page().(*ListStreamsOutput), !p.HasNextPage()) { + break + } + } + + return p.Err() +} + +const opListTagsForStream = "ListTagsForStream" + +// ListTagsForStreamRequest generates a "aws/request.Request" representing the +// client's request for the ListTagsForStream operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See ListTagsForStream for more information on using the ListTagsForStream +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the ListTagsForStreamRequest method. +// req, resp := client.ListTagsForStreamRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListTagsForStream +func (c *Kinesis) ListTagsForStreamRequest(input *ListTagsForStreamInput) (req *request.Request, output *ListTagsForStreamOutput) { + op := &request.Operation{ + Name: opListTagsForStream, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &ListTagsForStreamInput{} + } + + output = &ListTagsForStreamOutput{} + req = c.newRequest(op, input, output) + return +} + +// ListTagsForStream API operation for Amazon Kinesis. +// +// Lists the tags for the specified Kinesis data stream. This operation has +// a limit of five transactions per second per account. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation ListTagsForStream for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/ListTagsForStream +func (c *Kinesis) ListTagsForStream(input *ListTagsForStreamInput) (*ListTagsForStreamOutput, error) { + req, out := c.ListTagsForStreamRequest(input) + return out, req.Send() +} + +// ListTagsForStreamWithContext is the same as ListTagsForStream with the addition of +// the ability to pass a context and additional request options. +// +// See ListTagsForStream for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) ListTagsForStreamWithContext(ctx aws.Context, input *ListTagsForStreamInput, opts ...request.Option) (*ListTagsForStreamOutput, error) { + req, out := c.ListTagsForStreamRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opMergeShards = "MergeShards" + +// MergeShardsRequest generates a "aws/request.Request" representing the +// client's request for the MergeShards operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See MergeShards for more information on using the MergeShards +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the MergeShardsRequest method. +// req, resp := client.MergeShardsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/MergeShards +func (c *Kinesis) MergeShardsRequest(input *MergeShardsInput) (req *request.Request, output *MergeShardsOutput) { + op := &request.Operation{ + Name: opMergeShards, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &MergeShardsInput{} + } + + output = &MergeShardsOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// MergeShards API operation for Amazon Kinesis. +// +// 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. +// 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. +// +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-merge.html) +// 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 DescribeStream 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 DescribeStream 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation MergeShards for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/MergeShards +func (c *Kinesis) MergeShards(input *MergeShardsInput) (*MergeShardsOutput, error) { + req, out := c.MergeShardsRequest(input) + return out, req.Send() +} + +// MergeShardsWithContext is the same as MergeShards with the addition of +// the ability to pass a context and additional request options. +// +// See MergeShards for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) MergeShardsWithContext(ctx aws.Context, input *MergeShardsInput, opts ...request.Option) (*MergeShardsOutput, error) { + req, out := c.MergeShardsRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opPutRecord = "PutRecord" + +// PutRecordRequest generates a "aws/request.Request" representing the +// client's request for the PutRecord operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See PutRecord for more information on using the PutRecord +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the PutRecordRequest method. +// req, resp := client.PutRecordRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/PutRecord +func (c *Kinesis) PutRecordRequest(input *PutRecordInput) (req *request.Request, output *PutRecordOutput) { + op := &request.Operation{ + Name: opPutRecord, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &PutRecordInput{} + } + + output = &PutRecordOutput{} + req = c.newRequest(op, input, output) + return +} + +// PutRecord API operation for Amazon Kinesis. +// +// 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. +// +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-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 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation PutRecord for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * ProvisionedThroughputExceededException +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and +// Exponential Backoff in AWS (https://docs.aws.amazon.com/general/latest/gr/api-retries.html) +// in the AWS General Reference. +// +// * KMSDisabledException +// The request was rejected because the specified customer master key (CMK) +// isn't enabled. +// +// * KMSInvalidStateException +// 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 (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html) +// in the AWS Key Management Service Developer Guide. +// +// * KMSAccessDeniedException +// The ciphertext references a key that doesn't exist or that you don't have +// access to. +// +// * KMSNotFoundException +// The request was rejected because the specified entity or resource can't be +// found. +// +// * KMSOptInRequired +// The AWS access key ID needs a subscription for the service. +// +// * KMSThrottlingException +// The request was denied due to request throttling. For more information about +// throttling, see Limits (https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) +// in the AWS Key Management Service Developer Guide. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/PutRecord +func (c *Kinesis) PutRecord(input *PutRecordInput) (*PutRecordOutput, error) { + req, out := c.PutRecordRequest(input) + return out, req.Send() +} + +// PutRecordWithContext is the same as PutRecord with the addition of +// the ability to pass a context and additional request options. +// +// See PutRecord for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) PutRecordWithContext(ctx aws.Context, input *PutRecordInput, opts ...request.Option) (*PutRecordOutput, error) { + req, out := c.PutRecordRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opPutRecords = "PutRecords" + +// PutRecordsRequest generates a "aws/request.Request" representing the +// client's request for the PutRecords operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See PutRecords for more information on using the PutRecords +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the PutRecordsRequest method. +// req, resp := client.PutRecordsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/PutRecords +func (c *Kinesis) PutRecordsRequest(input *PutRecordsInput) (req *request.Request, output *PutRecordsOutput) { + op := &request.Operation{ + Name: opPutRecords, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &PutRecordsInput{} + } + + output = &PutRecordsOutput{} + req = c.newRequest(op, input, output) + return +} + +// PutRecords API operation for Amazon Kinesis. +// +// 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. +// +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-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 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-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 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-add-data-to-stream.html#kinesis-using-sdk-java-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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation PutRecords for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * ProvisionedThroughputExceededException +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and +// Exponential Backoff in AWS (https://docs.aws.amazon.com/general/latest/gr/api-retries.html) +// in the AWS General Reference. +// +// * KMSDisabledException +// The request was rejected because the specified customer master key (CMK) +// isn't enabled. +// +// * KMSInvalidStateException +// 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 (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html) +// in the AWS Key Management Service Developer Guide. +// +// * KMSAccessDeniedException +// The ciphertext references a key that doesn't exist or that you don't have +// access to. +// +// * KMSNotFoundException +// The request was rejected because the specified entity or resource can't be +// found. +// +// * KMSOptInRequired +// The AWS access key ID needs a subscription for the service. +// +// * KMSThrottlingException +// The request was denied due to request throttling. For more information about +// throttling, see Limits (https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) +// in the AWS Key Management Service Developer Guide. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/PutRecords +func (c *Kinesis) PutRecords(input *PutRecordsInput) (*PutRecordsOutput, error) { + req, out := c.PutRecordsRequest(input) + return out, req.Send() +} + +// PutRecordsWithContext is the same as PutRecords with the addition of +// the ability to pass a context and additional request options. +// +// See PutRecords for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) PutRecordsWithContext(ctx aws.Context, input *PutRecordsInput, opts ...request.Option) (*PutRecordsOutput, error) { + req, out := c.PutRecordsRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opRegisterStreamConsumer = "RegisterStreamConsumer" + +// RegisterStreamConsumerRequest generates a "aws/request.Request" representing the +// client's request for the RegisterStreamConsumer operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See RegisterStreamConsumer for more information on using the RegisterStreamConsumer +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the RegisterStreamConsumerRequest method. +// req, resp := client.RegisterStreamConsumerRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/RegisterStreamConsumer +func (c *Kinesis) RegisterStreamConsumerRequest(input *RegisterStreamConsumerInput) (req *request.Request, output *RegisterStreamConsumerOutput) { + op := &request.Operation{ + Name: opRegisterStreamConsumer, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RegisterStreamConsumerInput{} + } + + output = &RegisterStreamConsumerOutput{} + req = c.newRequest(op, input, output) + return +} + +// RegisterStreamConsumer API operation for Amazon Kinesis. +// +// 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 (/streams/latest/dev/building-enhanced-consumers-api.html). +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation RegisterStreamConsumer for usage and error information. +// +// Returned Error Types: +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/RegisterStreamConsumer +func (c *Kinesis) RegisterStreamConsumer(input *RegisterStreamConsumerInput) (*RegisterStreamConsumerOutput, error) { + req, out := c.RegisterStreamConsumerRequest(input) + return out, req.Send() +} + +// RegisterStreamConsumerWithContext is the same as RegisterStreamConsumer with the addition of +// the ability to pass a context and additional request options. +// +// See RegisterStreamConsumer for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) RegisterStreamConsumerWithContext(ctx aws.Context, input *RegisterStreamConsumerInput, opts ...request.Option) (*RegisterStreamConsumerOutput, error) { + req, out := c.RegisterStreamConsumerRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opRemoveTagsFromStream = "RemoveTagsFromStream" + +// RemoveTagsFromStreamRequest generates a "aws/request.Request" representing the +// client's request for the RemoveTagsFromStream operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See RemoveTagsFromStream for more information on using the RemoveTagsFromStream +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the RemoveTagsFromStreamRequest method. +// req, resp := client.RemoveTagsFromStreamRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/RemoveTagsFromStream +func (c *Kinesis) RemoveTagsFromStreamRequest(input *RemoveTagsFromStreamInput) (req *request.Request, output *RemoveTagsFromStreamOutput) { + op := &request.Operation{ + Name: opRemoveTagsFromStream, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &RemoveTagsFromStreamInput{} + } + + output = &RemoveTagsFromStreamOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// RemoveTagsFromStream API operation for Amazon Kinesis. +// +// Removes tags from the specified Kinesis data stream. Removed tags are deleted +// and cannot be recovered after this operation successfully completes. +// +// If you specify a tag that does not exist, it is ignored. +// +// RemoveTagsFromStream has a limit of five transactions per second per account. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation RemoveTagsFromStream for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/RemoveTagsFromStream +func (c *Kinesis) RemoveTagsFromStream(input *RemoveTagsFromStreamInput) (*RemoveTagsFromStreamOutput, error) { + req, out := c.RemoveTagsFromStreamRequest(input) + return out, req.Send() +} + +// RemoveTagsFromStreamWithContext is the same as RemoveTagsFromStream with the addition of +// the ability to pass a context and additional request options. +// +// See RemoveTagsFromStream for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) RemoveTagsFromStreamWithContext(ctx aws.Context, input *RemoveTagsFromStreamInput, opts ...request.Option) (*RemoveTagsFromStreamOutput, error) { + req, out := c.RemoveTagsFromStreamRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opSplitShard = "SplitShard" + +// SplitShardRequest generates a "aws/request.Request" representing the +// client's request for the SplitShard operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See SplitShard for more information on using the SplitShard +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the SplitShardRequest method. +// req, resp := client.SplitShardRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/SplitShard +func (c *Kinesis) SplitShardRequest(input *SplitShardInput) (req *request.Request, output *SplitShardOutput) { + op := &request.Operation{ + Name: opSplitShard, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &SplitShardInput{} + } + + output = &SplitShardOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// SplitShard API operation for Amazon Kinesis. +// +// 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. +// +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html) +// in the Amazon Kinesis Data Streams Developer Guide. +// +// You can use DescribeStream 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 DescribeStream 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 a stream is in CREATING or UPDATING or DELETING states, DescribeStream +// returns a ResourceInUseException. +// +// If the specified stream does not exist, DescribeStream 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 AWS account, see Kinesis Data Streams +// Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// in the Amazon Kinesis Data Streams Developer Guide. To increase this limit, +// contact AWS Support (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html). +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation SplitShard for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/SplitShard +func (c *Kinesis) SplitShard(input *SplitShardInput) (*SplitShardOutput, error) { + req, out := c.SplitShardRequest(input) + return out, req.Send() +} + +// SplitShardWithContext is the same as SplitShard with the addition of +// the ability to pass a context and additional request options. +// +// See SplitShard for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) SplitShardWithContext(ctx aws.Context, input *SplitShardInput, opts ...request.Option) (*SplitShardOutput, error) { + req, out := c.SplitShardRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opStartStreamEncryption = "StartStreamEncryption" + +// StartStreamEncryptionRequest generates a "aws/request.Request" representing the +// client's request for the StartStreamEncryption operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See StartStreamEncryption for more information on using the StartStreamEncryption +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the StartStreamEncryptionRequest method. +// req, resp := client.StartStreamEncryptionRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/StartStreamEncryption +func (c *Kinesis) StartStreamEncryptionRequest(input *StartStreamEncryptionInput) (req *request.Request, output *StartStreamEncryptionOutput) { + op := &request.Operation{ + Name: opStartStreamEncryption, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &StartStreamEncryptionInput{} + } + + output = &StartStreamEncryptionOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// StartStreamEncryption API operation for Amazon Kinesis. +// +// Enables or updates server-side encryption using an AWS 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 AWS 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation StartStreamEncryption for usage and error information. +// +// Returned Error Types: +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * KMSDisabledException +// The request was rejected because the specified customer master key (CMK) +// isn't enabled. +// +// * KMSInvalidStateException +// 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 (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html) +// in the AWS Key Management Service Developer Guide. +// +// * KMSAccessDeniedException +// The ciphertext references a key that doesn't exist or that you don't have +// access to. +// +// * KMSNotFoundException +// The request was rejected because the specified entity or resource can't be +// found. +// +// * KMSOptInRequired +// The AWS access key ID needs a subscription for the service. +// +// * KMSThrottlingException +// The request was denied due to request throttling. For more information about +// throttling, see Limits (https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) +// in the AWS Key Management Service Developer Guide. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/StartStreamEncryption +func (c *Kinesis) StartStreamEncryption(input *StartStreamEncryptionInput) (*StartStreamEncryptionOutput, error) { + req, out := c.StartStreamEncryptionRequest(input) + return out, req.Send() +} + +// StartStreamEncryptionWithContext is the same as StartStreamEncryption with the addition of +// the ability to pass a context and additional request options. +// +// See StartStreamEncryption for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) StartStreamEncryptionWithContext(ctx aws.Context, input *StartStreamEncryptionInput, opts ...request.Option) (*StartStreamEncryptionOutput, error) { + req, out := c.StartStreamEncryptionRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opStopStreamEncryption = "StopStreamEncryption" + +// StopStreamEncryptionRequest generates a "aws/request.Request" representing the +// client's request for the StopStreamEncryption operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See StopStreamEncryption for more information on using the StopStreamEncryption +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the StopStreamEncryptionRequest method. +// req, resp := client.StopStreamEncryptionRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/StopStreamEncryption +func (c *Kinesis) StopStreamEncryptionRequest(input *StopStreamEncryptionInput) (req *request.Request, output *StopStreamEncryptionOutput) { + op := &request.Operation{ + Name: opStopStreamEncryption, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &StopStreamEncryptionInput{} + } + + output = &StopStreamEncryptionOutput{} + req = c.newRequest(op, input, output) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) + return +} + +// StopStreamEncryption API operation for Amazon Kinesis. +// +// Disables server-side encryption for a specified stream. +// +// 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. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation StopStreamEncryption for usage and error information. +// +// Returned Error Types: +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/StopStreamEncryption +func (c *Kinesis) StopStreamEncryption(input *StopStreamEncryptionInput) (*StopStreamEncryptionOutput, error) { + req, out := c.StopStreamEncryptionRequest(input) + return out, req.Send() +} + +// StopStreamEncryptionWithContext is the same as StopStreamEncryption with the addition of +// the ability to pass a context and additional request options. +// +// See StopStreamEncryption for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) StopStreamEncryptionWithContext(ctx aws.Context, input *StopStreamEncryptionInput, opts ...request.Option) (*StopStreamEncryptionOutput, error) { + req, out := c.StopStreamEncryptionRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +const opSubscribeToShard = "SubscribeToShard" + +// SubscribeToShardRequest generates a "aws/request.Request" representing the +// client's request for the SubscribeToShard operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See SubscribeToShard for more information on using the SubscribeToShard +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the SubscribeToShardRequest method. +// req, resp := client.SubscribeToShardRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/SubscribeToShard +func (c *Kinesis) SubscribeToShardRequest(input *SubscribeToShardInput) (req *request.Request, output *SubscribeToShardOutput) { + op := &request.Operation{ + Name: opSubscribeToShard, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &SubscribeToShardInput{} + } + + output = &SubscribeToShardOutput{} + req = c.newRequest(op, input, output) + + es := NewSubscribeToShardEventStream() + req.Handlers.Unmarshal.PushBack(es.setStreamCloser) + output.EventStream = es + + req.Handlers.Send.Swap(client.LogHTTPResponseHandler.Name, client.LogHTTPResponseHeaderHandler) + req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, rest.UnmarshalHandler) + req.Handlers.Unmarshal.PushBack(es.runOutputStream) + es.output = output + req.Handlers.Unmarshal.PushBack(es.recvInitialEvent) + req.Handlers.Unmarshal.PushBack(es.runOnStreamPartClose) + return +} + +// SubscribeToShard API operation for Amazon Kinesis. +// +// This operation establishes an HTTP/2 connection between the consumer you +// specify in the ConsumerARN parameter and the shard you specify in the ShardId +// parameter. After the connection is successfully established, Kinesis Data +// Streams pushes records from the shard to the consumer over this connection. +// Before you call this operation, call RegisterStreamConsumer to register the +// consumer with Kinesis Data Streams. +// +// When the SubscribeToShard call succeeds, your consumer starts receiving events +// of type SubscribeToShardEvent over the HTTP/2 connection for up to 5 minutes, +// after which time you need to call SubscribeToShard again to renew the subscription +// if you want to continue to receive records. +// +// You can make one call to SubscribeToShard per second per registered consumer +// per shard. For example, if you have a 4000 shard stream and two registered +// stream consumers, you can make one SubscribeToShard request per second for +// each combination of shard and registered consumer, allowing you to subscribe +// both consumers to all 4000 shards in one second. +// +// If you call SubscribeToShard again with the same ConsumerARN and ShardId +// within 5 seconds of a successful call, you'll get a ResourceInUseException. +// If you call SubscribeToShard 5 seconds or more after a successful call, the +// first connection will expire and the second call will take over the subscription. +// +// For an example of how to use this operations, see Enhanced Fan-Out Using +// the Kinesis Data Streams API (/streams/latest/dev/building-enhanced-consumers-api.html). +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation SubscribeToShard for usage and error information. +// +// Returned Error Types: +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/SubscribeToShard +func (c *Kinesis) SubscribeToShard(input *SubscribeToShardInput) (*SubscribeToShardOutput, error) { + req, out := c.SubscribeToShardRequest(input) + return out, req.Send() +} + +// SubscribeToShardWithContext is the same as SubscribeToShard with the addition of +// the ability to pass a context and additional request options. +// +// See SubscribeToShard for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) SubscribeToShardWithContext(ctx aws.Context, input *SubscribeToShardInput, opts ...request.Option) (*SubscribeToShardOutput, error) { + req, out := c.SubscribeToShardRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +var _ awserr.Error + +// SubscribeToShardEventStream provides the event stream handling for the SubscribeToShard. +// +// For testing and mocking the event stream this type should be initialized via +// the NewSubscribeToShardEventStream constructor function. Using the functional options +// to pass in nested mock behavior. +type SubscribeToShardEventStream struct { + + // Reader is the EventStream reader for the SubscribeToShardEventStream + // events. This value is automatically set by the SDK when the API call is made + // Use this member when unit testing your code with the SDK to mock out the + // EventStream Reader. + // + // Must not be nil. + Reader SubscribeToShardEventStreamReader + + outputReader io.ReadCloser + output *SubscribeToShardOutput + + // StreamCloser is the io.Closer for the EventStream connection. For HTTP + // EventStream this is the response Body. The stream will be closed when + // the Close method of the EventStream is called. + StreamCloser io.Closer + + done chan struct{} + closeOnce sync.Once + err *eventstreamapi.OnceError +} + +// NewSubscribeToShardEventStream initializes an SubscribeToShardEventStream. +// This function should only be used for testing and mocking the SubscribeToShardEventStream +// stream within your application. +// +// The Reader member must be set before reading events from the stream. +// +// The StreamCloser member should be set to the underlying io.Closer, +// (e.g. http.Response.Body), that will be closed when the stream Close method +// is called. +// +// es := NewSubscribeToShardEventStream(func(o *SubscribeToShardEventStream{ +// es.Reader = myMockStreamReader +// es.StreamCloser = myMockStreamCloser +// }) +func NewSubscribeToShardEventStream(opts ...func(*SubscribeToShardEventStream)) *SubscribeToShardEventStream { + es := &SubscribeToShardEventStream{ + done: make(chan struct{}), + err: eventstreamapi.NewOnceError(), + } + + for _, fn := range opts { + fn(es) + } + + return es +} + +func (es *SubscribeToShardEventStream) setStreamCloser(r *request.Request) { + es.StreamCloser = r.HTTPResponse.Body +} + +func (es *SubscribeToShardEventStream) runOnStreamPartClose(r *request.Request) { + if es.done == nil { + return + } + go es.waitStreamPartClose() + +} + +func (es *SubscribeToShardEventStream) waitStreamPartClose() { + var outputErrCh <-chan struct{} + if v, ok := es.Reader.(interface{ ErrorSet() <-chan struct{} }); ok { + outputErrCh = v.ErrorSet() + } + var outputClosedCh <-chan struct{} + if v, ok := es.Reader.(interface{ Closed() <-chan struct{} }); ok { + outputClosedCh = v.Closed() + } + + select { + case <-es.done: + case <-outputErrCh: + es.err.SetError(es.Reader.Err()) + es.Close() + case <-outputClosedCh: + if err := es.Reader.Err(); err != nil { + es.err.SetError(es.Reader.Err()) + } + es.Close() + } +} + +type eventTypeForSubscribeToShardEventStreamOutputEvent struct { + unmarshalerForEvent func(string) (eventstreamapi.Unmarshaler, error) + output *SubscribeToShardOutput +} + +func (e eventTypeForSubscribeToShardEventStreamOutputEvent) UnmarshalerForEventName(eventType string) (eventstreamapi.Unmarshaler, error) { + if eventType == "initial-response" { + return e.output, nil + } + return e.unmarshalerForEvent(eventType) +} + +// Events returns a channel to read events from. +// +// These events are: +// +// * SubscribeToShardEvent +// * SubscribeToShardEventStreamUnknownEvent +func (es *SubscribeToShardEventStream) Events() <-chan SubscribeToShardEventStreamEvent { + return es.Reader.Events() +} + +func (es *SubscribeToShardEventStream) runOutputStream(r *request.Request) { + var opts []func(*eventstream.Decoder) + if r.Config.Logger != nil && r.Config.LogLevel.Matches(aws.LogDebugWithEventStreamBody) { + opts = append(opts, eventstream.DecodeWithLogger(r.Config.Logger)) + } + + unmarshalerForEvent := unmarshalerForSubscribeToShardEventStreamEvent{ + metadata: protocol.ResponseMetadata{ + StatusCode: r.HTTPResponse.StatusCode, + RequestID: r.RequestID, + }, + }.UnmarshalerForEventName + unmarshalerForEvent = eventTypeForSubscribeToShardEventStreamOutputEvent{ + unmarshalerForEvent: unmarshalerForEvent, + output: es.output, + }.UnmarshalerForEventName + + decoder := eventstream.NewDecoder(r.HTTPResponse.Body, opts...) + eventReader := eventstreamapi.NewEventReader(decoder, + protocol.HandlerPayloadUnmarshal{ + Unmarshalers: r.Handlers.UnmarshalStream, + }, + unmarshalerForEvent, + ) + + es.outputReader = r.HTTPResponse.Body + es.Reader = newReadSubscribeToShardEventStream(eventReader) +} +func (es *SubscribeToShardEventStream) recvInitialEvent(r *request.Request) { + // Wait for the initial response event, which must be the first + // event to be received from the API. + select { + case event, ok := <-es.Events(): + if !ok { + return + } + + v, ok := event.(*SubscribeToShardOutput) + if !ok || v == nil { + r.Error = awserr.New( + request.ErrCodeSerialization, + fmt.Sprintf("invalid event, %T, expect %T, %v", + event, (*SubscribeToShardOutput)(nil), v), + nil, + ) + return + } + + *es.output = *v + es.output.EventStream = es + } +} + +// Close closes the stream. This will also cause the stream to be closed. +// Close must be called when done using the stream API. Not calling Close +// may result in resource leaks. +// +// You can use the closing of the Reader's Events channel to terminate your +// application's read from the API's stream. +// +func (es *SubscribeToShardEventStream) Close() (err error) { + es.closeOnce.Do(es.safeClose) + return es.Err() +} + +func (es *SubscribeToShardEventStream) safeClose() { + if es.done != nil { + close(es.done) + } + + es.Reader.Close() + if es.outputReader != nil { + es.outputReader.Close() + } + + es.StreamCloser.Close() +} + +// Err returns any error that occurred while reading or writing EventStream +// Events from the service API's response. Returns nil if there were no errors. +func (es *SubscribeToShardEventStream) Err() error { + if err := es.err.Err(); err != nil { + return err + } + if err := es.Reader.Err(); err != nil { + return err + } + + return nil +} + +const opUpdateShardCount = "UpdateShardCount" + +// UpdateShardCountRequest generates a "aws/request.Request" representing the +// client's request for the UpdateShardCount operation. The "output" return +// value will be populated with the request's response once the request completes +// successfully. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See UpdateShardCount for more information on using the UpdateShardCount +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the UpdateShardCountRequest method. +// req, resp := client.UpdateShardCountRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateShardCount +func (c *Kinesis) UpdateShardCountRequest(input *UpdateShardCountInput) (req *request.Request, output *UpdateShardCountOutput) { + op := &request.Operation{ + Name: opUpdateShardCount, + HTTPMethod: "POST", + HTTPPath: "/", + } + + if input == nil { + input = &UpdateShardCountInput{} + } + + output = &UpdateShardCountOutput{} + req = c.newRequest(op, input, output) + return +} + +// UpdateShardCount API operation for Amazon Kinesis. +// +// Updates the shard count of the specified stream to the specified number of +// shards. +// +// 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: +// +// * Scale more than ten times per rolling 24-hour period per stream +// +// * Scale up to more than double your current shard count for a stream +// +// * Scale down below half your current shard count for a stream +// +// * Scale up to more than 500 shards in a stream +// +// * Scale a stream with more than 500 shards down unless the result is less +// than 500 shards +// +// * Scale up to more than the shard limit for your account +// +// For the default limits for an AWS account, see Streams Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// 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 (https://console.aws.amazon.com/support/v1#/case/create?issueType=service-limit-increase&limitType=service-code-kinesis). +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for Amazon Kinesis's +// API operation UpdateShardCount for usage and error information. +// +// Returned Error Types: +// * InvalidArgumentException +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +// +// * LimitExceededException +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +// +// * ResourceInUseException +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +// +// * ResourceNotFoundException +// The requested resource could not be found. The stream might not be specified +// correctly. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateShardCount +func (c *Kinesis) UpdateShardCount(input *UpdateShardCountInput) (*UpdateShardCountOutput, error) { + req, out := c.UpdateShardCountRequest(input) + return out, req.Send() +} + +// UpdateShardCountWithContext is the same as UpdateShardCount with the addition of +// the ability to pass a context and additional request options. +// +// See UpdateShardCount for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) UpdateShardCountWithContext(ctx aws.Context, input *UpdateShardCountInput, opts ...request.Option) (*UpdateShardCountOutput, error) { + req, out := c.UpdateShardCountRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +// Represents the input for AddTagsToStream. +type AddTagsToStreamInput struct { + _ struct{} `type:"structure"` + + // The name of the stream. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` + + // A set of up to 10 key-value pairs to use to create the tags. + // + // Tags is a required field + Tags map[string]*string `min:"1" type:"map" required:"true"` +} + +// String returns the string representation +func (s AddTagsToStreamInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s AddTagsToStreamInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *AddTagsToStreamInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "AddTagsToStreamInput"} + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + if s.Tags == nil { + invalidParams.Add(request.NewErrParamRequired("Tags")) + } + if s.Tags != nil && len(s.Tags) < 1 { + invalidParams.Add(request.NewErrParamMinLen("Tags", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetStreamName sets the StreamName field's value. +func (s *AddTagsToStreamInput) SetStreamName(v string) *AddTagsToStreamInput { + s.StreamName = &v + return s +} + +// SetTags sets the Tags field's value. +func (s *AddTagsToStreamInput) SetTags(v map[string]*string) *AddTagsToStreamInput { + s.Tags = v + return s +} + +type AddTagsToStreamOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s AddTagsToStreamOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s AddTagsToStreamOutput) GoString() string { + return s.String() +} + +type ChildShard struct { + _ struct{} `type:"structure"` + + // The range of possible hash key values for the shard, which is a set of ordered + // contiguous positive integers. + // + // HashKeyRange is a required field + HashKeyRange *HashKeyRange `type:"structure" required:"true"` + + // ParentShards is a required field + ParentShards []*string `type:"list" required:"true"` + + // ShardId is a required field + ShardId *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s ChildShard) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ChildShard) GoString() string { + return s.String() +} + +// SetHashKeyRange sets the HashKeyRange field's value. +func (s *ChildShard) SetHashKeyRange(v *HashKeyRange) *ChildShard { + s.HashKeyRange = v + return s +} + +// SetParentShards sets the ParentShards field's value. +func (s *ChildShard) SetParentShards(v []*string) *ChildShard { + s.ParentShards = v + return s +} + +// SetShardId sets the ShardId field's value. +func (s *ChildShard) SetShardId(v string) *ChildShard { + s.ShardId = &v + return s +} + +// An object that represents the details of the consumer you registered. This +// type of object is returned by RegisterStreamConsumer. +type Consumer struct { + _ struct{} `type:"structure"` + + // When you register a consumer, Kinesis Data Streams generates an ARN for it. + // You need this ARN to be able to call SubscribeToShard. + // + // If you delete a consumer and then create a new one with the same name, it + // won't have the same ARN. That's because consumer ARNs contain the creation + // timestamp. This is important to keep in mind if you have IAM policies that + // reference consumer ARNs. + // + // ConsumerARN is a required field + ConsumerARN *string `min:"1" type:"string" required:"true"` + + // ConsumerCreationTimestamp is a required field + ConsumerCreationTimestamp *time.Time `type:"timestamp" required:"true"` + + // The name of the consumer is something you choose when you register the consumer. + // + // ConsumerName is a required field + ConsumerName *string `min:"1" type:"string" required:"true"` + + // A consumer can't read data while in the CREATING or DELETING states. + // + // ConsumerStatus is a required field + ConsumerStatus *string `type:"string" required:"true" enum:"ConsumerStatus"` +} + +// String returns the string representation +func (s Consumer) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Consumer) GoString() string { + return s.String() +} + +// SetConsumerARN sets the ConsumerARN field's value. +func (s *Consumer) SetConsumerARN(v string) *Consumer { + s.ConsumerARN = &v + return s +} + +// SetConsumerCreationTimestamp sets the ConsumerCreationTimestamp field's value. +func (s *Consumer) SetConsumerCreationTimestamp(v time.Time) *Consumer { + s.ConsumerCreationTimestamp = &v + return s +} + +// SetConsumerName sets the ConsumerName field's value. +func (s *Consumer) SetConsumerName(v string) *Consumer { + s.ConsumerName = &v + return s +} + +// SetConsumerStatus sets the ConsumerStatus field's value. +func (s *Consumer) SetConsumerStatus(v string) *Consumer { + s.ConsumerStatus = &v + return s +} + +// An object that represents the details of a registered consumer. This type +// of object is returned by DescribeStreamConsumer. +type ConsumerDescription struct { + _ struct{} `type:"structure"` + + // When you register a consumer, Kinesis Data Streams generates an ARN for it. + // You need this ARN to be able to call SubscribeToShard. + // + // If you delete a consumer and then create a new one with the same name, it + // won't have the same ARN. That's because consumer ARNs contain the creation + // timestamp. This is important to keep in mind if you have IAM policies that + // reference consumer ARNs. + // + // ConsumerARN is a required field + ConsumerARN *string `min:"1" type:"string" required:"true"` + + // ConsumerCreationTimestamp is a required field + ConsumerCreationTimestamp *time.Time `type:"timestamp" required:"true"` + + // The name of the consumer is something you choose when you register the consumer. + // + // ConsumerName is a required field + ConsumerName *string `min:"1" type:"string" required:"true"` + + // A consumer can't read data while in the CREATING or DELETING states. + // + // ConsumerStatus is a required field + ConsumerStatus *string `type:"string" required:"true" enum:"ConsumerStatus"` + + // The ARN of the stream with which you registered the consumer. + // + // StreamARN is a required field + StreamARN *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s ConsumerDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ConsumerDescription) GoString() string { + return s.String() +} + +// SetConsumerARN sets the ConsumerARN field's value. +func (s *ConsumerDescription) SetConsumerARN(v string) *ConsumerDescription { + s.ConsumerARN = &v + return s +} + +// SetConsumerCreationTimestamp sets the ConsumerCreationTimestamp field's value. +func (s *ConsumerDescription) SetConsumerCreationTimestamp(v time.Time) *ConsumerDescription { + s.ConsumerCreationTimestamp = &v + return s +} + +// SetConsumerName sets the ConsumerName field's value. +func (s *ConsumerDescription) SetConsumerName(v string) *ConsumerDescription { + s.ConsumerName = &v + return s +} + +// SetConsumerStatus sets the ConsumerStatus field's value. +func (s *ConsumerDescription) SetConsumerStatus(v string) *ConsumerDescription { + s.ConsumerStatus = &v + return s +} + +// SetStreamARN sets the StreamARN field's value. +func (s *ConsumerDescription) SetStreamARN(v string) *ConsumerDescription { + s.StreamARN = &v + return s +} + +// Represents the input for CreateStream. +type CreateStreamInput struct { + _ struct{} `type:"structure"` + + // The number of shards that the stream will use. The throughput of the stream + // is a function of the number of shards; more shards are required for greater + // provisioned throughput. + // + // ShardCount is a required field + ShardCount *int64 `min:"1" type:"integer" required:"true"` + + // A name to identify the stream. The stream name is scoped to the AWS account + // used by the application that creates the stream. It is also scoped by AWS + // Region. That is, two streams in two different AWS accounts can have the same + // name. Two streams in the same AWS account but in two different Regions can + // also have the same name. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s CreateStreamInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateStreamInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *CreateStreamInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "CreateStreamInput"} + if s.ShardCount == nil { + invalidParams.Add(request.NewErrParamRequired("ShardCount")) + } + if s.ShardCount != nil && *s.ShardCount < 1 { + invalidParams.Add(request.NewErrParamMinValue("ShardCount", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetShardCount sets the ShardCount field's value. +func (s *CreateStreamInput) SetShardCount(v int64) *CreateStreamInput { + s.ShardCount = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *CreateStreamInput) SetStreamName(v string) *CreateStreamInput { + s.StreamName = &v + return s +} + +type CreateStreamOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s CreateStreamOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s CreateStreamOutput) GoString() string { + return s.String() +} + +// Represents the input for DecreaseStreamRetentionPeriod. +type DecreaseStreamRetentionPeriodInput struct { + _ struct{} `type:"structure"` + + // The new retention period of the stream, in hours. Must be less than the current + // retention period. + // + // RetentionPeriodHours is a required field + RetentionPeriodHours *int64 `type:"integer" required:"true"` + + // The name of the stream to modify. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s DecreaseStreamRetentionPeriodInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DecreaseStreamRetentionPeriodInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DecreaseStreamRetentionPeriodInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DecreaseStreamRetentionPeriodInput"} + if s.RetentionPeriodHours == nil { + invalidParams.Add(request.NewErrParamRequired("RetentionPeriodHours")) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetRetentionPeriodHours sets the RetentionPeriodHours field's value. +func (s *DecreaseStreamRetentionPeriodInput) SetRetentionPeriodHours(v int64) *DecreaseStreamRetentionPeriodInput { + s.RetentionPeriodHours = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *DecreaseStreamRetentionPeriodInput) SetStreamName(v string) *DecreaseStreamRetentionPeriodInput { + s.StreamName = &v + return s +} + +type DecreaseStreamRetentionPeriodOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DecreaseStreamRetentionPeriodOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DecreaseStreamRetentionPeriodOutput) GoString() string { + return s.String() +} + +// Represents the input for DeleteStream. +type DeleteStreamInput struct { + _ struct{} `type:"structure"` + + // If this parameter is unset (null) or if you set it to false, and the stream + // has registered consumers, the call to DeleteStream fails with a ResourceInUseException. + EnforceConsumerDeletion *bool `type:"boolean"` + + // The name of the stream to delete. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s DeleteStreamInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteStreamInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DeleteStreamInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DeleteStreamInput"} + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetEnforceConsumerDeletion sets the EnforceConsumerDeletion field's value. +func (s *DeleteStreamInput) SetEnforceConsumerDeletion(v bool) *DeleteStreamInput { + s.EnforceConsumerDeletion = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *DeleteStreamInput) SetStreamName(v string) *DeleteStreamInput { + s.StreamName = &v + return s +} + +type DeleteStreamOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DeleteStreamOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeleteStreamOutput) GoString() string { + return s.String() +} + +type DeregisterStreamConsumerInput struct { + _ struct{} `type:"structure"` + + // The ARN returned by Kinesis Data Streams when you registered the consumer. + // If you don't know the 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 ARN. + ConsumerARN *string `min:"1" type:"string"` + + // The name that you gave to the consumer. + ConsumerName *string `min:"1" type:"string"` + + // The ARN of the Kinesis data stream that the consumer is registered with. + // For more information, see Amazon Resource Names (ARNs) and AWS Service Namespaces + // (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams). + StreamARN *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s DeregisterStreamConsumerInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeregisterStreamConsumerInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DeregisterStreamConsumerInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DeregisterStreamConsumerInput"} + if s.ConsumerARN != nil && len(*s.ConsumerARN) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ConsumerARN", 1)) + } + if s.ConsumerName != nil && len(*s.ConsumerName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ConsumerName", 1)) + } + if s.StreamARN != nil && len(*s.StreamARN) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetConsumerARN sets the ConsumerARN field's value. +func (s *DeregisterStreamConsumerInput) SetConsumerARN(v string) *DeregisterStreamConsumerInput { + s.ConsumerARN = &v + return s +} + +// SetConsumerName sets the ConsumerName field's value. +func (s *DeregisterStreamConsumerInput) SetConsumerName(v string) *DeregisterStreamConsumerInput { + s.ConsumerName = &v + return s +} + +// SetStreamARN sets the StreamARN field's value. +func (s *DeregisterStreamConsumerInput) SetStreamARN(v string) *DeregisterStreamConsumerInput { + s.StreamARN = &v + return s +} + +type DeregisterStreamConsumerOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DeregisterStreamConsumerOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DeregisterStreamConsumerOutput) GoString() string { + return s.String() +} + +type DescribeLimitsInput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s DescribeLimitsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeLimitsInput) GoString() string { + return s.String() +} + +type DescribeLimitsOutput struct { + _ struct{} `type:"structure"` + + // The number of open shards. + // + // OpenShardCount is a required field + OpenShardCount *int64 `type:"integer" required:"true"` + + // The maximum number of shards. + // + // ShardLimit is a required field + ShardLimit *int64 `type:"integer" required:"true"` +} + +// String returns the string representation +func (s DescribeLimitsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeLimitsOutput) GoString() string { + return s.String() +} + +// SetOpenShardCount sets the OpenShardCount field's value. +func (s *DescribeLimitsOutput) SetOpenShardCount(v int64) *DescribeLimitsOutput { + s.OpenShardCount = &v + return s +} + +// SetShardLimit sets the ShardLimit field's value. +func (s *DescribeLimitsOutput) SetShardLimit(v int64) *DescribeLimitsOutput { + s.ShardLimit = &v + return s +} + +type DescribeStreamConsumerInput struct { + _ struct{} `type:"structure"` + + // The ARN returned by Kinesis Data Streams when you registered the consumer. + ConsumerARN *string `min:"1" type:"string"` + + // The name that you gave to the consumer. + ConsumerName *string `min:"1" type:"string"` + + // The ARN of the Kinesis data stream that the consumer is registered with. + // For more information, see Amazon Resource Names (ARNs) and AWS Service Namespaces + // (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams). + StreamARN *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s DescribeStreamConsumerInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeStreamConsumerInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DescribeStreamConsumerInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DescribeStreamConsumerInput"} + if s.ConsumerARN != nil && len(*s.ConsumerARN) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ConsumerARN", 1)) + } + if s.ConsumerName != nil && len(*s.ConsumerName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ConsumerName", 1)) + } + if s.StreamARN != nil && len(*s.StreamARN) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetConsumerARN sets the ConsumerARN field's value. +func (s *DescribeStreamConsumerInput) SetConsumerARN(v string) *DescribeStreamConsumerInput { + s.ConsumerARN = &v + return s +} + +// SetConsumerName sets the ConsumerName field's value. +func (s *DescribeStreamConsumerInput) SetConsumerName(v string) *DescribeStreamConsumerInput { + s.ConsumerName = &v + return s +} + +// SetStreamARN sets the StreamARN field's value. +func (s *DescribeStreamConsumerInput) SetStreamARN(v string) *DescribeStreamConsumerInput { + s.StreamARN = &v + return s +} + +type DescribeStreamConsumerOutput struct { + _ struct{} `type:"structure"` + + // An object that represents the details of the consumer. + // + // ConsumerDescription is a required field + ConsumerDescription *ConsumerDescription `type:"structure" required:"true"` +} + +// String returns the string representation +func (s DescribeStreamConsumerOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeStreamConsumerOutput) GoString() string { + return s.String() +} + +// SetConsumerDescription sets the ConsumerDescription field's value. +func (s *DescribeStreamConsumerOutput) SetConsumerDescription(v *ConsumerDescription) *DescribeStreamConsumerOutput { + s.ConsumerDescription = v + return s +} + +// Represents the input for DescribeStream. +type DescribeStreamInput struct { + _ struct{} `type:"structure"` + + // The shard ID of the shard to start with. + ExclusiveStartShardId *string `min:"1" type:"string"` + + // The maximum number of shards to return in a single call. The default value + // is 100. If you specify a value greater than 100, at most 100 shards are returned. + Limit *int64 `min:"1" type:"integer"` + + // The name of the stream to describe. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s DescribeStreamInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeStreamInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DescribeStreamInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DescribeStreamInput"} + if s.ExclusiveStartShardId != nil && len(*s.ExclusiveStartShardId) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ExclusiveStartShardId", 1)) + } + if s.Limit != nil && *s.Limit < 1 { + invalidParams.Add(request.NewErrParamMinValue("Limit", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetExclusiveStartShardId sets the ExclusiveStartShardId field's value. +func (s *DescribeStreamInput) SetExclusiveStartShardId(v string) *DescribeStreamInput { + s.ExclusiveStartShardId = &v + return s +} + +// SetLimit sets the Limit field's value. +func (s *DescribeStreamInput) SetLimit(v int64) *DescribeStreamInput { + s.Limit = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *DescribeStreamInput) SetStreamName(v string) *DescribeStreamInput { + s.StreamName = &v + return s +} + +// Represents the output for DescribeStream. +type DescribeStreamOutput struct { + _ struct{} `type:"structure"` + + // The current status of the stream, the stream Amazon Resource Name (ARN), + // an array of shard objects that comprise the stream, and whether there are + // more shards available. + // + // StreamDescription is a required field + StreamDescription *StreamDescription `type:"structure" required:"true"` +} + +// String returns the string representation +func (s DescribeStreamOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeStreamOutput) GoString() string { + return s.String() +} + +// SetStreamDescription sets the StreamDescription field's value. +func (s *DescribeStreamOutput) SetStreamDescription(v *StreamDescription) *DescribeStreamOutput { + s.StreamDescription = v + return s +} + +type DescribeStreamSummaryInput struct { + _ struct{} `type:"structure"` + + // The name of the stream to describe. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s DescribeStreamSummaryInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeStreamSummaryInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DescribeStreamSummaryInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DescribeStreamSummaryInput"} + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetStreamName sets the StreamName field's value. +func (s *DescribeStreamSummaryInput) SetStreamName(v string) *DescribeStreamSummaryInput { + s.StreamName = &v + return s +} + +type DescribeStreamSummaryOutput struct { + _ struct{} `type:"structure"` + + // A StreamDescriptionSummary containing information about the stream. + // + // StreamDescriptionSummary is a required field + StreamDescriptionSummary *StreamDescriptionSummary `type:"structure" required:"true"` +} + +// String returns the string representation +func (s DescribeStreamSummaryOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeStreamSummaryOutput) GoString() string { + return s.String() +} + +// SetStreamDescriptionSummary sets the StreamDescriptionSummary field's value. +func (s *DescribeStreamSummaryOutput) SetStreamDescriptionSummary(v *StreamDescriptionSummary) *DescribeStreamSummaryOutput { + s.StreamDescriptionSummary = v + return s +} + +// Represents the input for DisableEnhancedMonitoring. +type DisableEnhancedMonitoringInput struct { + _ struct{} `type:"structure"` + + // List of shard-level metrics to disable. + // + // The following are the valid shard-level metrics. The value "ALL" disables + // every metric. + // + // * IncomingBytes + // + // * IncomingRecords + // + // * OutgoingBytes + // + // * OutgoingRecords + // + // * WriteProvisionedThroughputExceeded + // + // * ReadProvisionedThroughputExceeded + // + // * IteratorAgeMilliseconds + // + // * ALL + // + // For more information, see Monitoring the Amazon Kinesis Data Streams Service + // with Amazon CloudWatch (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html) + // in the Amazon Kinesis Data Streams Developer Guide. + // + // ShardLevelMetrics is a required field + ShardLevelMetrics []*string `min:"1" type:"list" required:"true"` + + // The name of the Kinesis data stream for which to disable enhanced monitoring. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s DisableEnhancedMonitoringInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DisableEnhancedMonitoringInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DisableEnhancedMonitoringInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DisableEnhancedMonitoringInput"} + if s.ShardLevelMetrics == nil { + invalidParams.Add(request.NewErrParamRequired("ShardLevelMetrics")) + } + if s.ShardLevelMetrics != nil && len(s.ShardLevelMetrics) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardLevelMetrics", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetShardLevelMetrics sets the ShardLevelMetrics field's value. +func (s *DisableEnhancedMonitoringInput) SetShardLevelMetrics(v []*string) *DisableEnhancedMonitoringInput { + s.ShardLevelMetrics = v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *DisableEnhancedMonitoringInput) SetStreamName(v string) *DisableEnhancedMonitoringInput { + s.StreamName = &v + return s +} + +// Represents the input for EnableEnhancedMonitoring. +type EnableEnhancedMonitoringInput struct { + _ struct{} `type:"structure"` + + // List of shard-level metrics to enable. + // + // The following are the valid shard-level metrics. The value "ALL" enables + // every metric. + // + // * IncomingBytes + // + // * IncomingRecords + // + // * OutgoingBytes + // + // * OutgoingRecords + // + // * WriteProvisionedThroughputExceeded + // + // * ReadProvisionedThroughputExceeded + // + // * IteratorAgeMilliseconds + // + // * ALL + // + // For more information, see Monitoring the Amazon Kinesis Data Streams Service + // with Amazon CloudWatch (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html) + // in the Amazon Kinesis Data Streams Developer Guide. + // + // ShardLevelMetrics is a required field + ShardLevelMetrics []*string `min:"1" type:"list" required:"true"` + + // The name of the stream for which to enable enhanced monitoring. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s EnableEnhancedMonitoringInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnableEnhancedMonitoringInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *EnableEnhancedMonitoringInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "EnableEnhancedMonitoringInput"} + if s.ShardLevelMetrics == nil { + invalidParams.Add(request.NewErrParamRequired("ShardLevelMetrics")) + } + if s.ShardLevelMetrics != nil && len(s.ShardLevelMetrics) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardLevelMetrics", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetShardLevelMetrics sets the ShardLevelMetrics field's value. +func (s *EnableEnhancedMonitoringInput) SetShardLevelMetrics(v []*string) *EnableEnhancedMonitoringInput { + s.ShardLevelMetrics = v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *EnableEnhancedMonitoringInput) SetStreamName(v string) *EnableEnhancedMonitoringInput { + s.StreamName = &v + return s +} + +// Represents enhanced metrics types. +type EnhancedMetrics struct { + _ struct{} `type:"structure"` + + // List of shard-level metrics. + // + // The following are the valid shard-level metrics. The value "ALL" enhances + // every metric. + // + // * IncomingBytes + // + // * IncomingRecords + // + // * OutgoingBytes + // + // * OutgoingRecords + // + // * WriteProvisionedThroughputExceeded + // + // * ReadProvisionedThroughputExceeded + // + // * IteratorAgeMilliseconds + // + // * ALL + // + // For more information, see Monitoring the Amazon Kinesis Data Streams Service + // with Amazon CloudWatch (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html) + // in the Amazon Kinesis Data Streams Developer Guide. + ShardLevelMetrics []*string `min:"1" type:"list"` +} + +// String returns the string representation +func (s EnhancedMetrics) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnhancedMetrics) GoString() string { + return s.String() +} + +// SetShardLevelMetrics sets the ShardLevelMetrics field's value. +func (s *EnhancedMetrics) SetShardLevelMetrics(v []*string) *EnhancedMetrics { + s.ShardLevelMetrics = v + return s +} + +// Represents the output for EnableEnhancedMonitoring and DisableEnhancedMonitoring. +type EnhancedMonitoringOutput struct { + _ struct{} `type:"structure"` + + // Represents the current state of the metrics that are in the enhanced state + // before the operation. + CurrentShardLevelMetrics []*string `min:"1" type:"list"` + + // Represents the list of all the metrics that would be in the enhanced state + // after the operation. + DesiredShardLevelMetrics []*string `min:"1" type:"list"` + + // The name of the Kinesis data stream. + StreamName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s EnhancedMonitoringOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s EnhancedMonitoringOutput) GoString() string { + return s.String() +} + +// SetCurrentShardLevelMetrics sets the CurrentShardLevelMetrics field's value. +func (s *EnhancedMonitoringOutput) SetCurrentShardLevelMetrics(v []*string) *EnhancedMonitoringOutput { + s.CurrentShardLevelMetrics = v + return s +} + +// SetDesiredShardLevelMetrics sets the DesiredShardLevelMetrics field's value. +func (s *EnhancedMonitoringOutput) SetDesiredShardLevelMetrics(v []*string) *EnhancedMonitoringOutput { + s.DesiredShardLevelMetrics = v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *EnhancedMonitoringOutput) SetStreamName(v string) *EnhancedMonitoringOutput { + s.StreamName = &v + return s +} + +// The provided iterator exceeds the maximum age allowed. +type ExpiredIteratorException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s ExpiredIteratorException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ExpiredIteratorException) GoString() string { + return s.String() +} + +func newErrorExpiredIteratorException(v protocol.ResponseMetadata) error { + return &ExpiredIteratorException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *ExpiredIteratorException) Code() string { + return "ExpiredIteratorException" +} + +// Message returns the exception's message. +func (s *ExpiredIteratorException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *ExpiredIteratorException) OrigErr() error { + return nil +} + +func (s *ExpiredIteratorException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *ExpiredIteratorException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *ExpiredIteratorException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The pagination token passed to the operation is expired. +type ExpiredNextTokenException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s ExpiredNextTokenException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ExpiredNextTokenException) GoString() string { + return s.String() +} + +func newErrorExpiredNextTokenException(v protocol.ResponseMetadata) error { + return &ExpiredNextTokenException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *ExpiredNextTokenException) Code() string { + return "ExpiredNextTokenException" +} + +// Message returns the exception's message. +func (s *ExpiredNextTokenException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *ExpiredNextTokenException) OrigErr() error { + return nil +} + +func (s *ExpiredNextTokenException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *ExpiredNextTokenException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *ExpiredNextTokenException) RequestID() string { + return s.RespMetadata.RequestID +} + +// Represents the input for GetRecords. +type GetRecordsInput struct { + _ struct{} `type:"structure"` + + // The maximum number of records to return. Specify a value of up to 10,000. + // If you specify a value that is greater than 10,000, GetRecords throws InvalidArgumentException. + // The default value is 10,000. + Limit *int64 `min:"1" type:"integer"` + + // The position in the shard from which you want to start sequentially reading + // data records. A shard iterator specifies this position using the sequence + // number of a data record in the shard. + // + // ShardIterator is a required field + ShardIterator *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s GetRecordsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetRecordsInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetRecordsInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "GetRecordsInput"} + if s.Limit != nil && *s.Limit < 1 { + invalidParams.Add(request.NewErrParamMinValue("Limit", 1)) + } + if s.ShardIterator == nil { + invalidParams.Add(request.NewErrParamRequired("ShardIterator")) + } + if s.ShardIterator != nil && len(*s.ShardIterator) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardIterator", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetLimit sets the Limit field's value. +func (s *GetRecordsInput) SetLimit(v int64) *GetRecordsInput { + s.Limit = &v + return s +} + +// SetShardIterator sets the ShardIterator field's value. +func (s *GetRecordsInput) SetShardIterator(v string) *GetRecordsInput { + s.ShardIterator = &v + return s +} + +// Represents the output for GetRecords. +type GetRecordsOutput struct { + _ struct{} `type:"structure"` + + ChildShards []*ChildShard `type:"list"` + + // The number of milliseconds the GetRecords response is from the tip of the + // stream, indicating how far behind current time the consumer is. A value of + // zero indicates that record processing is caught up, and there are no new + // records to process at this moment. + MillisBehindLatest *int64 `type:"long"` + + // The next position in the shard from which to start sequentially reading data + // records. If set to null, the shard has been closed and the requested iterator + // does not return any more data. + NextShardIterator *string `min:"1" type:"string"` + + // The data records retrieved from the shard. + // + // Records is a required field + Records []*Record `type:"list" required:"true"` +} + +// String returns the string representation +func (s GetRecordsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetRecordsOutput) GoString() string { + return s.String() +} + +// SetChildShards sets the ChildShards field's value. +func (s *GetRecordsOutput) SetChildShards(v []*ChildShard) *GetRecordsOutput { + s.ChildShards = v + return s +} + +// SetMillisBehindLatest sets the MillisBehindLatest field's value. +func (s *GetRecordsOutput) SetMillisBehindLatest(v int64) *GetRecordsOutput { + s.MillisBehindLatest = &v + return s +} + +// SetNextShardIterator sets the NextShardIterator field's value. +func (s *GetRecordsOutput) SetNextShardIterator(v string) *GetRecordsOutput { + s.NextShardIterator = &v + return s +} + +// SetRecords sets the Records field's value. +func (s *GetRecordsOutput) SetRecords(v []*Record) *GetRecordsOutput { + s.Records = v + return s +} + +// Represents the input for GetShardIterator. +type GetShardIteratorInput struct { + _ struct{} `type:"structure"` + + // The shard ID of the Kinesis Data Streams shard to get the iterator for. + // + // ShardId is a required field + ShardId *string `min:"1" type:"string" required:"true"` + + // Determines how the shard iterator is used to start reading data records from + // the shard. + // + // The following are the valid Amazon Kinesis shard iterator types: + // + // * AT_SEQUENCE_NUMBER - Start reading from the position denoted by a specific + // sequence number, provided in the value StartingSequenceNumber. + // + // * AFTER_SEQUENCE_NUMBER - Start reading right after the position denoted + // by a specific sequence number, provided in the value StartingSequenceNumber. + // + // * AT_TIMESTAMP - Start reading from the position denoted by a specific + // time stamp, provided in the value Timestamp. + // + // * TRIM_HORIZON - Start reading at the last untrimmed record in the shard + // in the system, which is the oldest data record in the shard. + // + // * LATEST - Start reading just after the most recent record in the shard, + // so that you always read the most recent data in the shard. + // + // ShardIteratorType is a required field + ShardIteratorType *string `type:"string" required:"true" enum:"ShardIteratorType"` + + // The sequence number of the data record in the shard from which to start reading. + // Used with shard iterator type AT_SEQUENCE_NUMBER and AFTER_SEQUENCE_NUMBER. + StartingSequenceNumber *string `type:"string"` + + // The name of the Amazon Kinesis data stream. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` + + // The time stamp of the data record from which to start reading. Used with + // shard iterator type AT_TIMESTAMP. A time stamp is the Unix epoch date with + // precision in milliseconds. For example, 2016-04-04T19:58:46.480-00:00 or + // 1459799926.480. If a record with this exact time stamp does not exist, the + // iterator returned is for the next (later) record. If the time stamp is older + // than the current trim horizon, the iterator returned is for the oldest untrimmed + // data record (TRIM_HORIZON). + Timestamp *time.Time `type:"timestamp"` +} + +// String returns the string representation +func (s GetShardIteratorInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetShardIteratorInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetShardIteratorInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "GetShardIteratorInput"} + if s.ShardId == nil { + invalidParams.Add(request.NewErrParamRequired("ShardId")) + } + if s.ShardId != nil && len(*s.ShardId) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardId", 1)) + } + if s.ShardIteratorType == nil { + invalidParams.Add(request.NewErrParamRequired("ShardIteratorType")) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetShardId sets the ShardId field's value. +func (s *GetShardIteratorInput) SetShardId(v string) *GetShardIteratorInput { + s.ShardId = &v + return s +} + +// SetShardIteratorType sets the ShardIteratorType field's value. +func (s *GetShardIteratorInput) SetShardIteratorType(v string) *GetShardIteratorInput { + s.ShardIteratorType = &v + return s +} + +// SetStartingSequenceNumber sets the StartingSequenceNumber field's value. +func (s *GetShardIteratorInput) SetStartingSequenceNumber(v string) *GetShardIteratorInput { + s.StartingSequenceNumber = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *GetShardIteratorInput) SetStreamName(v string) *GetShardIteratorInput { + s.StreamName = &v + return s +} + +// SetTimestamp sets the Timestamp field's value. +func (s *GetShardIteratorInput) SetTimestamp(v time.Time) *GetShardIteratorInput { + s.Timestamp = &v + return s +} + +// Represents the output for GetShardIterator. +type GetShardIteratorOutput struct { + _ struct{} `type:"structure"` + + // The position in the shard from which to start reading data records sequentially. + // A shard iterator specifies this position using the sequence number of a data + // record in a shard. + ShardIterator *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s GetShardIteratorOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetShardIteratorOutput) GoString() string { + return s.String() +} + +// SetShardIterator sets the ShardIterator field's value. +func (s *GetShardIteratorOutput) SetShardIterator(v string) *GetShardIteratorOutput { + s.ShardIterator = &v + return s +} + +// The range of possible hash key values for the shard, which is a set of ordered +// contiguous positive integers. +type HashKeyRange struct { + _ struct{} `type:"structure"` + + // The ending hash key of the hash key range. + // + // EndingHashKey is a required field + EndingHashKey *string `type:"string" required:"true"` + + // The starting hash key of the hash key range. + // + // StartingHashKey is a required field + StartingHashKey *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s HashKeyRange) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s HashKeyRange) GoString() string { + return s.String() +} + +// SetEndingHashKey sets the EndingHashKey field's value. +func (s *HashKeyRange) SetEndingHashKey(v string) *HashKeyRange { + s.EndingHashKey = &v + return s +} + +// SetStartingHashKey sets the StartingHashKey field's value. +func (s *HashKeyRange) SetStartingHashKey(v string) *HashKeyRange { + s.StartingHashKey = &v + return s +} + +// Represents the input for IncreaseStreamRetentionPeriod. +type IncreaseStreamRetentionPeriodInput struct { + _ struct{} `type:"structure"` + + // The new retention period of the stream, in hours. Must be more than the current + // retention period. + // + // RetentionPeriodHours is a required field + RetentionPeriodHours *int64 `type:"integer" required:"true"` + + // The name of the stream to modify. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s IncreaseStreamRetentionPeriodInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s IncreaseStreamRetentionPeriodInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *IncreaseStreamRetentionPeriodInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "IncreaseStreamRetentionPeriodInput"} + if s.RetentionPeriodHours == nil { + invalidParams.Add(request.NewErrParamRequired("RetentionPeriodHours")) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetRetentionPeriodHours sets the RetentionPeriodHours field's value. +func (s *IncreaseStreamRetentionPeriodInput) SetRetentionPeriodHours(v int64) *IncreaseStreamRetentionPeriodInput { + s.RetentionPeriodHours = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *IncreaseStreamRetentionPeriodInput) SetStreamName(v string) *IncreaseStreamRetentionPeriodInput { + s.StreamName = &v + return s +} + +type IncreaseStreamRetentionPeriodOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s IncreaseStreamRetentionPeriodOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s IncreaseStreamRetentionPeriodOutput) GoString() string { + return s.String() +} + +// The processing of the request failed because of an unknown error, exception, +// or failure. +type InternalFailureException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s InternalFailureException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s InternalFailureException) GoString() string { + return s.String() +} + +// The InternalFailureException is and event in the SubscribeToShardEventStream group of events. +func (s *InternalFailureException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the InternalFailureException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *InternalFailureException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *InternalFailureException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorInternalFailureException(v protocol.ResponseMetadata) error { + return &InternalFailureException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *InternalFailureException) Code() string { + return "InternalFailureException" +} + +// Message returns the exception's message. +func (s *InternalFailureException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *InternalFailureException) OrigErr() error { + return nil +} + +func (s *InternalFailureException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *InternalFailureException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *InternalFailureException) RequestID() string { + return s.RespMetadata.RequestID +} + +// A specified parameter exceeds its restrictions, is not supported, or can't +// be used. For more information, see the returned message. +type InvalidArgumentException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s InvalidArgumentException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s InvalidArgumentException) GoString() string { + return s.String() +} + +func newErrorInvalidArgumentException(v protocol.ResponseMetadata) error { + return &InvalidArgumentException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *InvalidArgumentException) Code() string { + return "InvalidArgumentException" +} + +// Message returns the exception's message. +func (s *InvalidArgumentException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *InvalidArgumentException) OrigErr() error { + return nil +} + +func (s *InvalidArgumentException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *InvalidArgumentException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *InvalidArgumentException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The ciphertext references a key that doesn't exist or that you don't have +// access to. +type KMSAccessDeniedException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s KMSAccessDeniedException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s KMSAccessDeniedException) GoString() string { + return s.String() +} + +// The KMSAccessDeniedException is and event in the SubscribeToShardEventStream group of events. +func (s *KMSAccessDeniedException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the KMSAccessDeniedException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *KMSAccessDeniedException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *KMSAccessDeniedException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorKMSAccessDeniedException(v protocol.ResponseMetadata) error { + return &KMSAccessDeniedException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *KMSAccessDeniedException) Code() string { + return "KMSAccessDeniedException" +} + +// Message returns the exception's message. +func (s *KMSAccessDeniedException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *KMSAccessDeniedException) OrigErr() error { + return nil +} + +func (s *KMSAccessDeniedException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *KMSAccessDeniedException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *KMSAccessDeniedException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The request was rejected because the specified customer master key (CMK) +// isn't enabled. +type KMSDisabledException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s KMSDisabledException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s KMSDisabledException) GoString() string { + return s.String() +} + +// The KMSDisabledException is and event in the SubscribeToShardEventStream group of events. +func (s *KMSDisabledException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the KMSDisabledException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *KMSDisabledException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *KMSDisabledException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorKMSDisabledException(v protocol.ResponseMetadata) error { + return &KMSDisabledException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *KMSDisabledException) Code() string { + return "KMSDisabledException" +} + +// Message returns the exception's message. +func (s *KMSDisabledException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *KMSDisabledException) OrigErr() error { + return nil +} + +func (s *KMSDisabledException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *KMSDisabledException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *KMSDisabledException) RequestID() string { + return s.RespMetadata.RequestID +} + +// 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 (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html) +// in the AWS Key Management Service Developer Guide. +type KMSInvalidStateException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s KMSInvalidStateException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s KMSInvalidStateException) GoString() string { + return s.String() +} + +// The KMSInvalidStateException is and event in the SubscribeToShardEventStream group of events. +func (s *KMSInvalidStateException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the KMSInvalidStateException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *KMSInvalidStateException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *KMSInvalidStateException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorKMSInvalidStateException(v protocol.ResponseMetadata) error { + return &KMSInvalidStateException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *KMSInvalidStateException) Code() string { + return "KMSInvalidStateException" +} + +// Message returns the exception's message. +func (s *KMSInvalidStateException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *KMSInvalidStateException) OrigErr() error { + return nil +} + +func (s *KMSInvalidStateException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *KMSInvalidStateException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *KMSInvalidStateException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The request was rejected because the specified entity or resource can't be +// found. +type KMSNotFoundException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s KMSNotFoundException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s KMSNotFoundException) GoString() string { + return s.String() +} + +// The KMSNotFoundException is and event in the SubscribeToShardEventStream group of events. +func (s *KMSNotFoundException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the KMSNotFoundException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *KMSNotFoundException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *KMSNotFoundException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorKMSNotFoundException(v protocol.ResponseMetadata) error { + return &KMSNotFoundException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *KMSNotFoundException) Code() string { + return "KMSNotFoundException" +} + +// Message returns the exception's message. +func (s *KMSNotFoundException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *KMSNotFoundException) OrigErr() error { + return nil +} + +func (s *KMSNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *KMSNotFoundException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *KMSNotFoundException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The AWS access key ID needs a subscription for the service. +type KMSOptInRequired struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s KMSOptInRequired) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s KMSOptInRequired) GoString() string { + return s.String() +} + +// The KMSOptInRequired is and event in the SubscribeToShardEventStream group of events. +func (s *KMSOptInRequired) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the KMSOptInRequired value. +// This method is only used internally within the SDK's EventStream handling. +func (s *KMSOptInRequired) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *KMSOptInRequired) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorKMSOptInRequired(v protocol.ResponseMetadata) error { + return &KMSOptInRequired{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *KMSOptInRequired) Code() string { + return "KMSOptInRequired" +} + +// Message returns the exception's message. +func (s *KMSOptInRequired) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *KMSOptInRequired) OrigErr() error { + return nil +} + +func (s *KMSOptInRequired) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *KMSOptInRequired) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *KMSOptInRequired) RequestID() string { + return s.RespMetadata.RequestID +} + +// The request was denied due to request throttling. For more information about +// throttling, see Limits (https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) +// in the AWS Key Management Service Developer Guide. +type KMSThrottlingException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s KMSThrottlingException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s KMSThrottlingException) GoString() string { + return s.String() +} + +// The KMSThrottlingException is and event in the SubscribeToShardEventStream group of events. +func (s *KMSThrottlingException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the KMSThrottlingException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *KMSThrottlingException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *KMSThrottlingException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorKMSThrottlingException(v protocol.ResponseMetadata) error { + return &KMSThrottlingException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *KMSThrottlingException) Code() string { + return "KMSThrottlingException" +} + +// Message returns the exception's message. +func (s *KMSThrottlingException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *KMSThrottlingException) OrigErr() error { + return nil +} + +func (s *KMSThrottlingException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *KMSThrottlingException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *KMSThrottlingException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The requested resource exceeds the maximum number allowed, or the number +// of concurrent stream requests exceeds the maximum number allowed. +type LimitExceededException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s LimitExceededException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s LimitExceededException) GoString() string { + return s.String() +} + +func newErrorLimitExceededException(v protocol.ResponseMetadata) error { + return &LimitExceededException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *LimitExceededException) Code() string { + return "LimitExceededException" +} + +// Message returns the exception's message. +func (s *LimitExceededException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *LimitExceededException) OrigErr() error { + return nil +} + +func (s *LimitExceededException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *LimitExceededException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *LimitExceededException) RequestID() string { + return s.RespMetadata.RequestID +} + +type ListShardsInput struct { + _ struct{} `type:"structure"` + + // Specify this parameter to indicate that you want to list the shards starting + // with the shard whose ID immediately follows ExclusiveStartShardId. + // + // If you don't specify this parameter, the default behavior is for ListShards + // to list the shards starting with the first one in the stream. + // + // You cannot specify this parameter if you specify NextToken. + ExclusiveStartShardId *string `min:"1" type:"string"` + + // The maximum number of shards to return in a single call to ListShards. The + // minimum value you can specify for this parameter is 1, and the maximum is + // 10,000, which is also the default. + // + // When the number of shards to be listed is greater than the value of MaxResults, + // the response contains a NextToken value that you can use in a subsequent + // call to ListShards to list the next set of shards. + MaxResults *int64 `min:"1" type:"integer"` + + // When the number of shards in the data stream is greater than the default + // value for the MaxResults parameter, or if you explicitly specify a value + // for MaxResults that is less than the number of shards in the data stream, + // the response includes a pagination token named NextToken. You can specify + // this NextToken value in a subsequent call to ListShards to list the next + // set of shards. + // + // Don't specify StreamName or StreamCreationTimestamp if you specify NextToken + // because the latter unambiguously identifies the stream. + // + // You can optionally specify a value for the MaxResults parameter when you + // specify NextToken. If you specify a MaxResults value that is less than the + // number of shards that the operation returns if you don't specify MaxResults, + // the response will contain a new NextToken value. You can use the new NextToken + // value in a subsequent call to the ListShards operation. + // + // Tokens expire after 300 seconds. When you obtain a value for NextToken in + // the response to a call to ListShards, you have 300 seconds to use that value. + // If you specify an expired token in a call to ListShards, you get ExpiredNextTokenException. + NextToken *string `min:"1" type:"string"` + + ShardFilter *ShardFilter `type:"structure"` + + // Specify this input parameter to distinguish data streams that have the same + // name. For example, if you create a data stream and then delete it, and you + // later create another data stream with the same name, you can use this input + // parameter to specify which of the two streams you want to list the shards + // for. + // + // You cannot specify this parameter if you specify the NextToken parameter. + StreamCreationTimestamp *time.Time `type:"timestamp"` + + // The name of the data stream whose shards you want to list. + // + // You cannot specify this parameter if you specify the NextToken parameter. + StreamName *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s ListShardsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListShardsInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ListShardsInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ListShardsInput"} + if s.ExclusiveStartShardId != nil && len(*s.ExclusiveStartShardId) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ExclusiveStartShardId", 1)) + } + if s.MaxResults != nil && *s.MaxResults < 1 { + invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) + } + if s.NextToken != nil && len(*s.NextToken) < 1 { + invalidParams.Add(request.NewErrParamMinLen("NextToken", 1)) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + if s.ShardFilter != nil { + if err := s.ShardFilter.Validate(); err != nil { + invalidParams.AddNested("ShardFilter", err.(request.ErrInvalidParams)) + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetExclusiveStartShardId sets the ExclusiveStartShardId field's value. +func (s *ListShardsInput) SetExclusiveStartShardId(v string) *ListShardsInput { + s.ExclusiveStartShardId = &v + return s +} + +// SetMaxResults sets the MaxResults field's value. +func (s *ListShardsInput) SetMaxResults(v int64) *ListShardsInput { + s.MaxResults = &v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *ListShardsInput) SetNextToken(v string) *ListShardsInput { + s.NextToken = &v + return s +} + +// SetShardFilter sets the ShardFilter field's value. +func (s *ListShardsInput) SetShardFilter(v *ShardFilter) *ListShardsInput { + s.ShardFilter = v + return s +} + +// SetStreamCreationTimestamp sets the StreamCreationTimestamp field's value. +func (s *ListShardsInput) SetStreamCreationTimestamp(v time.Time) *ListShardsInput { + s.StreamCreationTimestamp = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *ListShardsInput) SetStreamName(v string) *ListShardsInput { + s.StreamName = &v + return s +} + +type ListShardsOutput struct { + _ struct{} `type:"structure"` + + // When the number of shards in the data stream is greater than the default + // value for the MaxResults parameter, or if you explicitly specify a value + // for MaxResults that is less than the number of shards in the data stream, + // the response includes a pagination token named NextToken. You can specify + // this NextToken value in a subsequent call to ListShards to list the next + // set of shards. For more information about the use of this pagination token + // when calling the ListShards operation, see ListShardsInput$NextToken. + // + // Tokens expire after 300 seconds. When you obtain a value for NextToken in + // the response to a call to ListShards, you have 300 seconds to use that value. + // If you specify an expired token in a call to ListShards, you get ExpiredNextTokenException. + NextToken *string `min:"1" type:"string"` + + // An array of JSON objects. Each object represents one shard and specifies + // the IDs of the shard, the shard's parent, and the shard that's adjacent to + // the shard's parent. Each object also contains the starting and ending hash + // keys and the starting and ending sequence numbers for the shard. + Shards []*Shard `type:"list"` +} + +// String returns the string representation +func (s ListShardsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListShardsOutput) GoString() string { + return s.String() +} + +// SetNextToken sets the NextToken field's value. +func (s *ListShardsOutput) SetNextToken(v string) *ListShardsOutput { + s.NextToken = &v + return s +} + +// SetShards sets the Shards field's value. +func (s *ListShardsOutput) SetShards(v []*Shard) *ListShardsOutput { + s.Shards = v + return s +} + +type ListStreamConsumersInput struct { + _ struct{} `type:"structure"` + + // The maximum number of consumers that you want a single call of ListStreamConsumers + // to return. + MaxResults *int64 `min:"1" type:"integer"` + + // When the number of consumers that are registered with the data stream is + // greater than the default value for the MaxResults parameter, or if you explicitly + // specify a value for MaxResults that is less than the number of consumers + // that are registered with the data stream, the response includes a pagination + // token named NextToken. You can specify this NextToken value in a subsequent + // call to ListStreamConsumers to list the next set of registered consumers. + // + // Don't specify StreamName or StreamCreationTimestamp if you specify NextToken + // because the latter unambiguously identifies the stream. + // + // You can optionally specify a value for the MaxResults parameter when you + // specify NextToken. If you specify a MaxResults value that is less than the + // number of consumers that the operation returns if you don't specify MaxResults, + // the response will contain a new NextToken value. You can use the new NextToken + // value in a subsequent call to the ListStreamConsumers operation to list the + // next set of consumers. + // + // Tokens expire after 300 seconds. When you obtain a value for NextToken in + // the response to a call to ListStreamConsumers, you have 300 seconds to use + // that value. If you specify an expired token in a call to ListStreamConsumers, + // you get ExpiredNextTokenException. + NextToken *string `min:"1" type:"string"` + + // The ARN of the Kinesis data stream for which you want to list the registered + // consumers. For more information, see Amazon Resource Names (ARNs) and AWS + // Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams). + // + // StreamARN is a required field + StreamARN *string `min:"1" type:"string" required:"true"` + + // Specify this input parameter to distinguish data streams that have the same + // name. For example, if you create a data stream and then delete it, and you + // later create another data stream with the same name, you can use this input + // parameter to specify which of the two streams you want to list the consumers + // for. + // + // You can't specify this parameter if you specify the NextToken parameter. + StreamCreationTimestamp *time.Time `type:"timestamp"` +} + +// String returns the string representation +func (s ListStreamConsumersInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListStreamConsumersInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ListStreamConsumersInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ListStreamConsumersInput"} + if s.MaxResults != nil && *s.MaxResults < 1 { + invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) + } + if s.NextToken != nil && len(*s.NextToken) < 1 { + invalidParams.Add(request.NewErrParamMinLen("NextToken", 1)) + } + if s.StreamARN == nil { + invalidParams.Add(request.NewErrParamRequired("StreamARN")) + } + if s.StreamARN != nil && len(*s.StreamARN) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetMaxResults sets the MaxResults field's value. +func (s *ListStreamConsumersInput) SetMaxResults(v int64) *ListStreamConsumersInput { + s.MaxResults = &v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *ListStreamConsumersInput) SetNextToken(v string) *ListStreamConsumersInput { + s.NextToken = &v + return s +} + +// SetStreamARN sets the StreamARN field's value. +func (s *ListStreamConsumersInput) SetStreamARN(v string) *ListStreamConsumersInput { + s.StreamARN = &v + return s +} + +// SetStreamCreationTimestamp sets the StreamCreationTimestamp field's value. +func (s *ListStreamConsumersInput) SetStreamCreationTimestamp(v time.Time) *ListStreamConsumersInput { + s.StreamCreationTimestamp = &v + return s +} + +type ListStreamConsumersOutput struct { + _ struct{} `type:"structure"` + + // An array of JSON objects. Each object represents one registered consumer. + Consumers []*Consumer `type:"list"` + + // When the number of consumers that are registered with the data stream is + // greater than the default value for the MaxResults parameter, or if you explicitly + // specify a value for MaxResults that is less than the number of registered + // consumers, the response includes a pagination token named NextToken. You + // can specify this NextToken value in a subsequent call to ListStreamConsumers + // to list the next set of registered consumers. For more information about + // the use of this pagination token when calling the ListStreamConsumers operation, + // see ListStreamConsumersInput$NextToken. + // + // Tokens expire after 300 seconds. When you obtain a value for NextToken in + // the response to a call to ListStreamConsumers, you have 300 seconds to use + // that value. If you specify an expired token in a call to ListStreamConsumers, + // you get ExpiredNextTokenException. + NextToken *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s ListStreamConsumersOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListStreamConsumersOutput) GoString() string { + return s.String() +} + +// SetConsumers sets the Consumers field's value. +func (s *ListStreamConsumersOutput) SetConsumers(v []*Consumer) *ListStreamConsumersOutput { + s.Consumers = v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *ListStreamConsumersOutput) SetNextToken(v string) *ListStreamConsumersOutput { + s.NextToken = &v + return s +} + +// Represents the input for ListStreams. +type ListStreamsInput struct { + _ struct{} `type:"structure"` + + // The name of the stream to start the list with. + ExclusiveStartStreamName *string `min:"1" type:"string"` + + // The maximum number of streams to list. + Limit *int64 `min:"1" type:"integer"` +} + +// String returns the string representation +func (s ListStreamsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListStreamsInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ListStreamsInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ListStreamsInput"} + if s.ExclusiveStartStreamName != nil && len(*s.ExclusiveStartStreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ExclusiveStartStreamName", 1)) + } + if s.Limit != nil && *s.Limit < 1 { + invalidParams.Add(request.NewErrParamMinValue("Limit", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetExclusiveStartStreamName sets the ExclusiveStartStreamName field's value. +func (s *ListStreamsInput) SetExclusiveStartStreamName(v string) *ListStreamsInput { + s.ExclusiveStartStreamName = &v + return s +} + +// SetLimit sets the Limit field's value. +func (s *ListStreamsInput) SetLimit(v int64) *ListStreamsInput { + s.Limit = &v + return s +} + +// Represents the output for ListStreams. +type ListStreamsOutput struct { + _ struct{} `type:"structure"` + + // If set to true, there are more streams available to list. + // + // HasMoreStreams is a required field + HasMoreStreams *bool `type:"boolean" required:"true"` + + // The names of the streams that are associated with the AWS account making + // the ListStreams request. + // + // StreamNames is a required field + StreamNames []*string `type:"list" required:"true"` +} + +// String returns the string representation +func (s ListStreamsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListStreamsOutput) GoString() string { + return s.String() +} + +// SetHasMoreStreams sets the HasMoreStreams field's value. +func (s *ListStreamsOutput) SetHasMoreStreams(v bool) *ListStreamsOutput { + s.HasMoreStreams = &v + return s +} + +// SetStreamNames sets the StreamNames field's value. +func (s *ListStreamsOutput) SetStreamNames(v []*string) *ListStreamsOutput { + s.StreamNames = v + return s +} + +// Represents the input for ListTagsForStream. +type ListTagsForStreamInput struct { + _ struct{} `type:"structure"` + + // The key to use as the starting point for the list of tags. If this parameter + // is set, ListTagsForStream gets all tags that occur after ExclusiveStartTagKey. + ExclusiveStartTagKey *string `min:"1" type:"string"` + + // The number of tags to return. If this number is less than the total number + // of tags associated with the stream, HasMoreTags is set to true. To list additional + // tags, set ExclusiveStartTagKey to the last key in the response. + Limit *int64 `min:"1" type:"integer"` + + // The name of the stream. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s ListTagsForStreamInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListTagsForStreamInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ListTagsForStreamInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ListTagsForStreamInput"} + if s.ExclusiveStartTagKey != nil && len(*s.ExclusiveStartTagKey) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ExclusiveStartTagKey", 1)) + } + if s.Limit != nil && *s.Limit < 1 { + invalidParams.Add(request.NewErrParamMinValue("Limit", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetExclusiveStartTagKey sets the ExclusiveStartTagKey field's value. +func (s *ListTagsForStreamInput) SetExclusiveStartTagKey(v string) *ListTagsForStreamInput { + s.ExclusiveStartTagKey = &v + return s +} + +// SetLimit sets the Limit field's value. +func (s *ListTagsForStreamInput) SetLimit(v int64) *ListTagsForStreamInput { + s.Limit = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *ListTagsForStreamInput) SetStreamName(v string) *ListTagsForStreamInput { + s.StreamName = &v + return s +} + +// Represents the output for ListTagsForStream. +type ListTagsForStreamOutput struct { + _ struct{} `type:"structure"` + + // If set to true, more tags are available. To request additional tags, set + // ExclusiveStartTagKey to the key of the last tag returned. + // + // HasMoreTags is a required field + HasMoreTags *bool `type:"boolean" required:"true"` + + // A list of tags associated with StreamName, starting with the first tag after + // ExclusiveStartTagKey and up to the specified Limit. + // + // Tags is a required field + Tags []*Tag `type:"list" required:"true"` +} + +// String returns the string representation +func (s ListTagsForStreamOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ListTagsForStreamOutput) GoString() string { + return s.String() +} + +// SetHasMoreTags sets the HasMoreTags field's value. +func (s *ListTagsForStreamOutput) SetHasMoreTags(v bool) *ListTagsForStreamOutput { + s.HasMoreTags = &v + return s +} + +// SetTags sets the Tags field's value. +func (s *ListTagsForStreamOutput) SetTags(v []*Tag) *ListTagsForStreamOutput { + s.Tags = v + return s +} + +// Represents the input for MergeShards. +type MergeShardsInput struct { + _ struct{} `type:"structure"` + + // The shard ID of the adjacent shard for the merge. + // + // AdjacentShardToMerge is a required field + AdjacentShardToMerge *string `min:"1" type:"string" required:"true"` + + // The shard ID of the shard to combine with the adjacent shard for the merge. + // + // ShardToMerge is a required field + ShardToMerge *string `min:"1" type:"string" required:"true"` + + // The name of the stream for the merge. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s MergeShardsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s MergeShardsInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *MergeShardsInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "MergeShardsInput"} + if s.AdjacentShardToMerge == nil { + invalidParams.Add(request.NewErrParamRequired("AdjacentShardToMerge")) + } + if s.AdjacentShardToMerge != nil && len(*s.AdjacentShardToMerge) < 1 { + invalidParams.Add(request.NewErrParamMinLen("AdjacentShardToMerge", 1)) + } + if s.ShardToMerge == nil { + invalidParams.Add(request.NewErrParamRequired("ShardToMerge")) + } + if s.ShardToMerge != nil && len(*s.ShardToMerge) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardToMerge", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetAdjacentShardToMerge sets the AdjacentShardToMerge field's value. +func (s *MergeShardsInput) SetAdjacentShardToMerge(v string) *MergeShardsInput { + s.AdjacentShardToMerge = &v + return s +} + +// SetShardToMerge sets the ShardToMerge field's value. +func (s *MergeShardsInput) SetShardToMerge(v string) *MergeShardsInput { + s.ShardToMerge = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *MergeShardsInput) SetStreamName(v string) *MergeShardsInput { + s.StreamName = &v + return s +} + +type MergeShardsOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s MergeShardsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s MergeShardsOutput) GoString() string { + return s.String() +} + +// 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) +// in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and +// Exponential Backoff in AWS (https://docs.aws.amazon.com/general/latest/gr/api-retries.html) +// in the AWS General Reference. +type ProvisionedThroughputExceededException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s ProvisionedThroughputExceededException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ProvisionedThroughputExceededException) GoString() string { + return s.String() +} + +func newErrorProvisionedThroughputExceededException(v protocol.ResponseMetadata) error { + return &ProvisionedThroughputExceededException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *ProvisionedThroughputExceededException) Code() string { + return "ProvisionedThroughputExceededException" +} + +// Message returns the exception's message. +func (s *ProvisionedThroughputExceededException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *ProvisionedThroughputExceededException) OrigErr() error { + return nil +} + +func (s *ProvisionedThroughputExceededException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *ProvisionedThroughputExceededException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *ProvisionedThroughputExceededException) RequestID() string { + return s.RespMetadata.RequestID +} + +// Represents the input for PutRecord. +type PutRecordInput struct { + _ struct{} `type:"structure"` + + // The data blob to put into the record, which is base64-encoded when the blob + // is serialized. When the data blob (the payload before base64-encoding) is + // added to the partition key size, the total size must not exceed the maximum + // record size (1 MiB). + // + // Data is automatically base64 encoded/decoded by the SDK. + // + // Data is a required field + Data []byte `type:"blob" required:"true"` + + // The hash value used to explicitly determine the shard the data record is + // assigned to by overriding the partition key hash. + ExplicitHashKey *string `type:"string"` + + // Determines which shard in the stream the data record is assigned to. Partition + // keys are Unicode strings with a maximum length limit of 256 characters for + // each key. Amazon Kinesis Data Streams uses the partition key as input to + // a hash function that maps the partition key and associated data to a specific + // shard. Specifically, 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. + // + // PartitionKey is a required field + PartitionKey *string `min:"1" type:"string" required:"true"` + + // Guarantees strictly increasing sequence numbers, for puts from the same client + // and to the same partition key. Usage: set the SequenceNumberForOrdering of + // record n to the sequence number of record n-1 (as returned in the result + // when putting record n-1). If this parameter is not set, records are coarsely + // ordered based on arrival time. + SequenceNumberForOrdering *string `type:"string"` + + // The name of the stream to put the data record into. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s PutRecordInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s PutRecordInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *PutRecordInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "PutRecordInput"} + if s.Data == nil { + invalidParams.Add(request.NewErrParamRequired("Data")) + } + if s.PartitionKey == nil { + invalidParams.Add(request.NewErrParamRequired("PartitionKey")) + } + if s.PartitionKey != nil && len(*s.PartitionKey) < 1 { + invalidParams.Add(request.NewErrParamMinLen("PartitionKey", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetData sets the Data field's value. +func (s *PutRecordInput) SetData(v []byte) *PutRecordInput { + s.Data = v + return s +} + +// SetExplicitHashKey sets the ExplicitHashKey field's value. +func (s *PutRecordInput) SetExplicitHashKey(v string) *PutRecordInput { + s.ExplicitHashKey = &v + return s +} + +// SetPartitionKey sets the PartitionKey field's value. +func (s *PutRecordInput) SetPartitionKey(v string) *PutRecordInput { + s.PartitionKey = &v + return s +} + +// SetSequenceNumberForOrdering sets the SequenceNumberForOrdering field's value. +func (s *PutRecordInput) SetSequenceNumberForOrdering(v string) *PutRecordInput { + s.SequenceNumberForOrdering = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *PutRecordInput) SetStreamName(v string) *PutRecordInput { + s.StreamName = &v + return s +} + +// Represents the output for PutRecord. +type PutRecordOutput struct { + _ struct{} `type:"structure"` + + // The encryption type to use on the record. This parameter can be one of the + // following values: + // + // * NONE: Do not encrypt the records in the stream. + // + // * KMS: Use server-side encryption on the records in the stream using a + // customer-managed AWS KMS key. + EncryptionType *string `type:"string" enum:"EncryptionType"` + + // The sequence number identifier that was assigned to the put data record. + // The sequence number for the record is unique across all records in the stream. + // A sequence number is the identifier associated with every record put into + // the stream. + // + // SequenceNumber is a required field + SequenceNumber *string `type:"string" required:"true"` + + // The shard ID of the shard where the data record was placed. + // + // ShardId is a required field + ShardId *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s PutRecordOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s PutRecordOutput) GoString() string { + return s.String() +} + +// SetEncryptionType sets the EncryptionType field's value. +func (s *PutRecordOutput) SetEncryptionType(v string) *PutRecordOutput { + s.EncryptionType = &v + return s +} + +// SetSequenceNumber sets the SequenceNumber field's value. +func (s *PutRecordOutput) SetSequenceNumber(v string) *PutRecordOutput { + s.SequenceNumber = &v + return s +} + +// SetShardId sets the ShardId field's value. +func (s *PutRecordOutput) SetShardId(v string) *PutRecordOutput { + s.ShardId = &v + return s +} + +// A PutRecords request. +type PutRecordsInput struct { + _ struct{} `type:"structure"` + + // The records associated with the request. + // + // Records is a required field + Records []*PutRecordsRequestEntry `min:"1" type:"list" required:"true"` + + // The stream name associated with the request. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s PutRecordsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s PutRecordsInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *PutRecordsInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "PutRecordsInput"} + if s.Records == nil { + invalidParams.Add(request.NewErrParamRequired("Records")) + } + if s.Records != nil && len(s.Records) < 1 { + invalidParams.Add(request.NewErrParamMinLen("Records", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + if s.Records != nil { + for i, v := range s.Records { + if v == nil { + continue + } + if err := v.Validate(); err != nil { + invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Records", i), err.(request.ErrInvalidParams)) + } + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetRecords sets the Records field's value. +func (s *PutRecordsInput) SetRecords(v []*PutRecordsRequestEntry) *PutRecordsInput { + s.Records = v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *PutRecordsInput) SetStreamName(v string) *PutRecordsInput { + s.StreamName = &v + return s +} + +// PutRecords results. +type PutRecordsOutput struct { + _ struct{} `type:"structure"` + + // The encryption type used on the records. This parameter can be one of the + // following values: + // + // * NONE: Do not encrypt the records. + // + // * KMS: Use server-side encryption on the records using a customer-managed + // AWS KMS key. + EncryptionType *string `type:"string" enum:"EncryptionType"` + + // The number of unsuccessfully processed records in a PutRecords request. + FailedRecordCount *int64 `min:"1" type:"integer"` + + // An array of successfully and unsuccessfully processed record results, correlated + // with the request by natural ordering. A record that is successfully added + // to a stream includes SequenceNumber and ShardId in the result. A record that + // fails to be added to a stream includes ErrorCode and ErrorMessage in the + // result. + // + // Records is a required field + Records []*PutRecordsResultEntry `min:"1" type:"list" required:"true"` +} + +// String returns the string representation +func (s PutRecordsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s PutRecordsOutput) GoString() string { + return s.String() +} + +// SetEncryptionType sets the EncryptionType field's value. +func (s *PutRecordsOutput) SetEncryptionType(v string) *PutRecordsOutput { + s.EncryptionType = &v + return s +} + +// SetFailedRecordCount sets the FailedRecordCount field's value. +func (s *PutRecordsOutput) SetFailedRecordCount(v int64) *PutRecordsOutput { + s.FailedRecordCount = &v + return s +} + +// SetRecords sets the Records field's value. +func (s *PutRecordsOutput) SetRecords(v []*PutRecordsResultEntry) *PutRecordsOutput { + s.Records = v + return s +} + +// Represents the output for PutRecords. +type PutRecordsRequestEntry struct { + _ struct{} `type:"structure"` + + // The data blob to put into the record, which is base64-encoded when the blob + // is serialized. When the data blob (the payload before base64-encoding) is + // added to the partition key size, the total size must not exceed the maximum + // record size (1 MiB). + // + // Data is automatically base64 encoded/decoded by the SDK. + // + // Data is a required field + Data []byte `type:"blob" required:"true"` + + // The hash value used to determine explicitly the shard that the data record + // is assigned to by overriding the partition key hash. + ExplicitHashKey *string `type:"string"` + + // Determines which shard in the stream the data record is assigned to. Partition + // keys are Unicode strings with a maximum length limit of 256 characters for + // each key. Amazon Kinesis Data Streams uses the partition key as input to + // a hash function that maps the partition key and associated data to a specific + // shard. Specifically, 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. + // + // PartitionKey is a required field + PartitionKey *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s PutRecordsRequestEntry) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s PutRecordsRequestEntry) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *PutRecordsRequestEntry) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "PutRecordsRequestEntry"} + if s.Data == nil { + invalidParams.Add(request.NewErrParamRequired("Data")) + } + if s.PartitionKey == nil { + invalidParams.Add(request.NewErrParamRequired("PartitionKey")) + } + if s.PartitionKey != nil && len(*s.PartitionKey) < 1 { + invalidParams.Add(request.NewErrParamMinLen("PartitionKey", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetData sets the Data field's value. +func (s *PutRecordsRequestEntry) SetData(v []byte) *PutRecordsRequestEntry { + s.Data = v + return s +} + +// SetExplicitHashKey sets the ExplicitHashKey field's value. +func (s *PutRecordsRequestEntry) SetExplicitHashKey(v string) *PutRecordsRequestEntry { + s.ExplicitHashKey = &v + return s +} + +// SetPartitionKey sets the PartitionKey field's value. +func (s *PutRecordsRequestEntry) SetPartitionKey(v string) *PutRecordsRequestEntry { + s.PartitionKey = &v + return s +} + +// Represents the result of an individual record from a PutRecords request. +// A record that is successfully added to a stream includes SequenceNumber and +// ShardId in the result. A record that fails to be added to the stream includes +// ErrorCode and ErrorMessage in the result. +type PutRecordsResultEntry struct { + _ struct{} `type:"structure"` + + // The error code for an individual record result. ErrorCodes can be either + // ProvisionedThroughputExceededException or InternalFailure. + ErrorCode *string `type:"string"` + + // The error message for an individual record result. An ErrorCode value of + // ProvisionedThroughputExceededException has an error message that includes + // the account ID, stream name, and shard ID. An ErrorCode value of InternalFailure + // has the error message "Internal Service Failure". + ErrorMessage *string `type:"string"` + + // The sequence number for an individual record result. + SequenceNumber *string `type:"string"` + + // The shard ID for an individual record result. + ShardId *string `min:"1" type:"string"` +} + +// String returns the string representation +func (s PutRecordsResultEntry) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s PutRecordsResultEntry) GoString() string { + return s.String() +} + +// SetErrorCode sets the ErrorCode field's value. +func (s *PutRecordsResultEntry) SetErrorCode(v string) *PutRecordsResultEntry { + s.ErrorCode = &v + return s +} + +// SetErrorMessage sets the ErrorMessage field's value. +func (s *PutRecordsResultEntry) SetErrorMessage(v string) *PutRecordsResultEntry { + s.ErrorMessage = &v + return s +} + +// SetSequenceNumber sets the SequenceNumber field's value. +func (s *PutRecordsResultEntry) SetSequenceNumber(v string) *PutRecordsResultEntry { + s.SequenceNumber = &v + return s +} + +// SetShardId sets the ShardId field's value. +func (s *PutRecordsResultEntry) SetShardId(v string) *PutRecordsResultEntry { + s.ShardId = &v + return s +} + +// The unit of data of the Kinesis data stream, which is composed of a sequence +// number, a partition key, and a data blob. +type Record struct { + _ struct{} `type:"structure"` + + // The approximate time that the record was inserted into the stream. + ApproximateArrivalTimestamp *time.Time `type:"timestamp"` + + // The data blob. The data in the blob is both opaque and immutable to Kinesis + // Data Streams, which does not inspect, interpret, or change the data in the + // blob in any way. When the data blob (the payload before base64-encoding) + // is added to the partition key size, the total size must not exceed the maximum + // record size (1 MiB). + // + // Data is automatically base64 encoded/decoded by the SDK. + // + // Data is a required field + Data []byte `type:"blob" required:"true"` + + // The encryption type used on the record. This parameter can be one of the + // following values: + // + // * NONE: Do not encrypt the records in the stream. + // + // * KMS: Use server-side encryption on the records in the stream using a + // customer-managed AWS KMS key. + EncryptionType *string `type:"string" enum:"EncryptionType"` + + // Identifies which shard in the stream the data record is assigned to. + // + // PartitionKey is a required field + PartitionKey *string `min:"1" type:"string" required:"true"` + + // The unique identifier of the record within its shard. + // + // SequenceNumber is a required field + SequenceNumber *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s Record) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Record) GoString() string { + return s.String() +} + +// SetApproximateArrivalTimestamp sets the ApproximateArrivalTimestamp field's value. +func (s *Record) SetApproximateArrivalTimestamp(v time.Time) *Record { + s.ApproximateArrivalTimestamp = &v + return s +} + +// SetData sets the Data field's value. +func (s *Record) SetData(v []byte) *Record { + s.Data = v + return s +} + +// SetEncryptionType sets the EncryptionType field's value. +func (s *Record) SetEncryptionType(v string) *Record { + s.EncryptionType = &v + return s +} + +// SetPartitionKey sets the PartitionKey field's value. +func (s *Record) SetPartitionKey(v string) *Record { + s.PartitionKey = &v + return s +} + +// SetSequenceNumber sets the SequenceNumber field's value. +func (s *Record) SetSequenceNumber(v string) *Record { + s.SequenceNumber = &v + return s +} + +type RegisterStreamConsumerInput struct { + _ struct{} `type:"structure"` + + // For a given Kinesis data stream, each consumer must have a unique name. However, + // consumer names don't have to be unique across data streams. + // + // ConsumerName is a required field + ConsumerName *string `min:"1" type:"string" required:"true"` + + // The ARN of the Kinesis data stream that you want to register the consumer + // with. For more info, see Amazon Resource Names (ARNs) and AWS Service Namespaces + // (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams). + // + // StreamARN is a required field + StreamARN *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s RegisterStreamConsumerInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RegisterStreamConsumerInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *RegisterStreamConsumerInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "RegisterStreamConsumerInput"} + if s.ConsumerName == nil { + invalidParams.Add(request.NewErrParamRequired("ConsumerName")) + } + if s.ConsumerName != nil && len(*s.ConsumerName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ConsumerName", 1)) + } + if s.StreamARN == nil { + invalidParams.Add(request.NewErrParamRequired("StreamARN")) + } + if s.StreamARN != nil && len(*s.StreamARN) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamARN", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetConsumerName sets the ConsumerName field's value. +func (s *RegisterStreamConsumerInput) SetConsumerName(v string) *RegisterStreamConsumerInput { + s.ConsumerName = &v + return s +} + +// SetStreamARN sets the StreamARN field's value. +func (s *RegisterStreamConsumerInput) SetStreamARN(v string) *RegisterStreamConsumerInput { + s.StreamARN = &v + return s +} + +type RegisterStreamConsumerOutput struct { + _ struct{} `type:"structure"` + + // An object that represents the details of the consumer you registered. When + // you register a consumer, it gets an ARN that is generated by Kinesis Data + // Streams. + // + // Consumer is a required field + Consumer *Consumer `type:"structure" required:"true"` +} + +// String returns the string representation +func (s RegisterStreamConsumerOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RegisterStreamConsumerOutput) GoString() string { + return s.String() +} + +// SetConsumer sets the Consumer field's value. +func (s *RegisterStreamConsumerOutput) SetConsumer(v *Consumer) *RegisterStreamConsumerOutput { + s.Consumer = v + return s +} + +// Represents the input for RemoveTagsFromStream. +type RemoveTagsFromStreamInput struct { + _ struct{} `type:"structure"` + + // The name of the stream. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` + + // A list of tag keys. Each corresponding tag is removed from the stream. + // + // TagKeys is a required field + TagKeys []*string `min:"1" type:"list" required:"true"` +} + +// String returns the string representation +func (s RemoveTagsFromStreamInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RemoveTagsFromStreamInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *RemoveTagsFromStreamInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "RemoveTagsFromStreamInput"} + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + if s.TagKeys == nil { + invalidParams.Add(request.NewErrParamRequired("TagKeys")) + } + if s.TagKeys != nil && len(s.TagKeys) < 1 { + invalidParams.Add(request.NewErrParamMinLen("TagKeys", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetStreamName sets the StreamName field's value. +func (s *RemoveTagsFromStreamInput) SetStreamName(v string) *RemoveTagsFromStreamInput { + s.StreamName = &v + return s +} + +// SetTagKeys sets the TagKeys field's value. +func (s *RemoveTagsFromStreamInput) SetTagKeys(v []*string) *RemoveTagsFromStreamInput { + s.TagKeys = v + return s +} + +type RemoveTagsFromStreamOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s RemoveTagsFromStreamOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s RemoveTagsFromStreamOutput) GoString() string { + return s.String() +} + +// The resource is not available for this operation. For successful operation, +// the resource must be in the ACTIVE state. +type ResourceInUseException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s ResourceInUseException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ResourceInUseException) GoString() string { + return s.String() +} + +// The ResourceInUseException is and event in the SubscribeToShardEventStream group of events. +func (s *ResourceInUseException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the ResourceInUseException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *ResourceInUseException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *ResourceInUseException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorResourceInUseException(v protocol.ResponseMetadata) error { + return &ResourceInUseException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *ResourceInUseException) Code() string { + return "ResourceInUseException" +} + +// Message returns the exception's message. +func (s *ResourceInUseException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *ResourceInUseException) OrigErr() error { + return nil +} + +func (s *ResourceInUseException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *ResourceInUseException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *ResourceInUseException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The requested resource could not be found. The stream might not be specified +// correctly. +type ResourceNotFoundException struct { + _ struct{} `type:"structure"` + RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"` + + // A message that provides information about the error. + Message_ *string `locationName:"message" type:"string"` +} + +// String returns the string representation +func (s ResourceNotFoundException) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ResourceNotFoundException) GoString() string { + return s.String() +} + +// The ResourceNotFoundException is and event in the SubscribeToShardEventStream group of events. +func (s *ResourceNotFoundException) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the ResourceNotFoundException value. +// This method is only used internally within the SDK's EventStream handling. +func (s *ResourceNotFoundException) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *ResourceNotFoundException) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.ExceptionMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +func newErrorResourceNotFoundException(v protocol.ResponseMetadata) error { + return &ResourceNotFoundException{ + RespMetadata: v, + } +} + +// Code returns the exception type name. +func (s *ResourceNotFoundException) Code() string { + return "ResourceNotFoundException" +} + +// Message returns the exception's message. +func (s *ResourceNotFoundException) Message() string { + if s.Message_ != nil { + return *s.Message_ + } + return "" +} + +// OrigErr always returns nil, satisfies awserr.Error interface. +func (s *ResourceNotFoundException) OrigErr() error { + return nil +} + +func (s *ResourceNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", s.Code(), s.Message()) +} + +// Status code returns the HTTP status code for the request's response error. +func (s *ResourceNotFoundException) StatusCode() int { + return s.RespMetadata.StatusCode +} + +// RequestID returns the service's response RequestID for request. +func (s *ResourceNotFoundException) RequestID() string { + return s.RespMetadata.RequestID +} + +// The range of possible sequence numbers for the shard. +type SequenceNumberRange struct { + _ struct{} `type:"structure"` + + // The ending sequence number for the range. Shards that are in the OPEN state + // have an ending sequence number of null. + EndingSequenceNumber *string `type:"string"` + + // The starting sequence number for the range. + // + // StartingSequenceNumber is a required field + StartingSequenceNumber *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s SequenceNumberRange) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SequenceNumberRange) GoString() string { + return s.String() +} + +// SetEndingSequenceNumber sets the EndingSequenceNumber field's value. +func (s *SequenceNumberRange) SetEndingSequenceNumber(v string) *SequenceNumberRange { + s.EndingSequenceNumber = &v + return s +} + +// SetStartingSequenceNumber sets the StartingSequenceNumber field's value. +func (s *SequenceNumberRange) SetStartingSequenceNumber(v string) *SequenceNumberRange { + s.StartingSequenceNumber = &v + return s +} + +// A uniquely identified group of data records in a Kinesis data stream. +type Shard struct { + _ struct{} `type:"structure"` + + // The shard ID of the shard adjacent to the shard's parent. + AdjacentParentShardId *string `min:"1" type:"string"` + + // The range of possible hash key values for the shard, which is a set of ordered + // contiguous positive integers. + // + // HashKeyRange is a required field + HashKeyRange *HashKeyRange `type:"structure" required:"true"` + + // The shard ID of the shard's parent. + ParentShardId *string `min:"1" type:"string"` + + // The range of possible sequence numbers for the shard. + // + // SequenceNumberRange is a required field + SequenceNumberRange *SequenceNumberRange `type:"structure" required:"true"` + + // The unique identifier of the shard within the stream. + // + // ShardId is a required field + ShardId *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s Shard) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Shard) GoString() string { + return s.String() +} + +// SetAdjacentParentShardId sets the AdjacentParentShardId field's value. +func (s *Shard) SetAdjacentParentShardId(v string) *Shard { + s.AdjacentParentShardId = &v + return s +} + +// SetHashKeyRange sets the HashKeyRange field's value. +func (s *Shard) SetHashKeyRange(v *HashKeyRange) *Shard { + s.HashKeyRange = v + return s +} + +// SetParentShardId sets the ParentShardId field's value. +func (s *Shard) SetParentShardId(v string) *Shard { + s.ParentShardId = &v + return s +} + +// SetSequenceNumberRange sets the SequenceNumberRange field's value. +func (s *Shard) SetSequenceNumberRange(v *SequenceNumberRange) *Shard { + s.SequenceNumberRange = v + return s +} + +// SetShardId sets the ShardId field's value. +func (s *Shard) SetShardId(v string) *Shard { + s.ShardId = &v + return s +} + +type ShardFilter struct { + _ struct{} `type:"structure"` + + ShardId *string `min:"1" type:"string"` + + Timestamp *time.Time `type:"timestamp"` + + // Type is a required field + Type *string `type:"string" required:"true" enum:"ShardFilterType"` +} + +// String returns the string representation +func (s ShardFilter) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s ShardFilter) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *ShardFilter) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "ShardFilter"} + if s.ShardId != nil && len(*s.ShardId) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardId", 1)) + } + if s.Type == nil { + invalidParams.Add(request.NewErrParamRequired("Type")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetShardId sets the ShardId field's value. +func (s *ShardFilter) SetShardId(v string) *ShardFilter { + s.ShardId = &v + return s +} + +// SetTimestamp sets the Timestamp field's value. +func (s *ShardFilter) SetTimestamp(v time.Time) *ShardFilter { + s.Timestamp = &v + return s +} + +// SetType sets the Type field's value. +func (s *ShardFilter) SetType(v string) *ShardFilter { + s.Type = &v + return s +} + +// Represents the input for SplitShard. +type SplitShardInput struct { + _ struct{} `type:"structure"` + + // A hash key value for the starting hash key of one of the child shards created + // by the split. The hash key range for a given shard constitutes a set of ordered + // contiguous positive integers. The value for NewStartingHashKey must be in + // the range of hash keys being mapped into the shard. The NewStartingHashKey + // hash key value and all higher hash key values in hash key range are distributed + // to one of the child shards. All the lower hash key values in the range are + // distributed to the other child shard. + // + // NewStartingHashKey is a required field + NewStartingHashKey *string `type:"string" required:"true"` + + // The shard ID of the shard to split. + // + // ShardToSplit is a required field + ShardToSplit *string `min:"1" type:"string" required:"true"` + + // The name of the stream for the shard split. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s SplitShardInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SplitShardInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *SplitShardInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "SplitShardInput"} + if s.NewStartingHashKey == nil { + invalidParams.Add(request.NewErrParamRequired("NewStartingHashKey")) + } + if s.ShardToSplit == nil { + invalidParams.Add(request.NewErrParamRequired("ShardToSplit")) + } + if s.ShardToSplit != nil && len(*s.ShardToSplit) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardToSplit", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetNewStartingHashKey sets the NewStartingHashKey field's value. +func (s *SplitShardInput) SetNewStartingHashKey(v string) *SplitShardInput { + s.NewStartingHashKey = &v + return s +} + +// SetShardToSplit sets the ShardToSplit field's value. +func (s *SplitShardInput) SetShardToSplit(v string) *SplitShardInput { + s.ShardToSplit = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *SplitShardInput) SetStreamName(v string) *SplitShardInput { + s.StreamName = &v + return s +} + +type SplitShardOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s SplitShardOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SplitShardOutput) GoString() string { + return s.String() +} + +type StartStreamEncryptionInput struct { + _ struct{} `type:"structure"` + + // The encryption type to use. The only valid value is KMS. + // + // EncryptionType is a required field + EncryptionType *string `type:"string" required:"true" enum:"EncryptionType"` + + // The GUID for the customer-managed AWS KMS key to use for encryption. This + // value can be a globally unique identifier, a fully specified Amazon Resource + // Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You + // can also use a master key owned by Kinesis Data Streams by specifying the + // alias aws/kinesis. + // + // * Key ARN example: arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012 + // + // * Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName + // + // * Globally unique key ID example: 12345678-1234-1234-1234-123456789012 + // + // * Alias name example: alias/MyAliasName + // + // * Master key owned by Kinesis Data Streams: alias/aws/kinesis + // + // KeyId is a required field + KeyId *string `min:"1" type:"string" required:"true"` + + // The name of the stream for which to start encrypting records. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s StartStreamEncryptionInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StartStreamEncryptionInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *StartStreamEncryptionInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "StartStreamEncryptionInput"} + if s.EncryptionType == nil { + invalidParams.Add(request.NewErrParamRequired("EncryptionType")) + } + if s.KeyId == nil { + invalidParams.Add(request.NewErrParamRequired("KeyId")) + } + if s.KeyId != nil && len(*s.KeyId) < 1 { + invalidParams.Add(request.NewErrParamMinLen("KeyId", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetEncryptionType sets the EncryptionType field's value. +func (s *StartStreamEncryptionInput) SetEncryptionType(v string) *StartStreamEncryptionInput { + s.EncryptionType = &v + return s +} + +// SetKeyId sets the KeyId field's value. +func (s *StartStreamEncryptionInput) SetKeyId(v string) *StartStreamEncryptionInput { + s.KeyId = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *StartStreamEncryptionInput) SetStreamName(v string) *StartStreamEncryptionInput { + s.StreamName = &v + return s +} + +type StartStreamEncryptionOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s StartStreamEncryptionOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StartStreamEncryptionOutput) GoString() string { + return s.String() +} + +type StartingPosition struct { + _ struct{} `type:"structure"` + + // The sequence number of the data record in the shard from which to start streaming. + // To specify a sequence number, set StartingPosition to AT_SEQUENCE_NUMBER + // or AFTER_SEQUENCE_NUMBER. + SequenceNumber *string `type:"string"` + + // The time stamp of the data record from which to start reading. To specify + // a time stamp, set StartingPosition to Type AT_TIMESTAMP. A time stamp is + // the Unix epoch date with precision in milliseconds. For example, 2016-04-04T19:58:46.480-00:00 + // or 1459799926.480. If a record with this exact time stamp does not exist, + // records will be streamed from the next (later) record. If the time stamp + // is older than the current trim horizon, records will be streamed from the + // oldest untrimmed data record (TRIM_HORIZON). + Timestamp *time.Time `type:"timestamp"` + + // You can set the starting position to one of the following values: + // + // AT_SEQUENCE_NUMBER: Start streaming from the position denoted by the sequence + // number specified in the SequenceNumber field. + // + // AFTER_SEQUENCE_NUMBER: Start streaming right after the position denoted by + // the sequence number specified in the SequenceNumber field. + // + // AT_TIMESTAMP: Start streaming from the position denoted by the time stamp + // specified in the Timestamp field. + // + // TRIM_HORIZON: Start streaming at the last untrimmed record in the shard, + // which is the oldest data record in the shard. + // + // LATEST: Start streaming just after the most recent record in the shard, so + // that you always read the most recent data in the shard. + // + // Type is a required field + Type *string `type:"string" required:"true" enum:"ShardIteratorType"` +} + +// String returns the string representation +func (s StartingPosition) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StartingPosition) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *StartingPosition) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "StartingPosition"} + if s.Type == nil { + invalidParams.Add(request.NewErrParamRequired("Type")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetSequenceNumber sets the SequenceNumber field's value. +func (s *StartingPosition) SetSequenceNumber(v string) *StartingPosition { + s.SequenceNumber = &v + return s +} + +// SetTimestamp sets the Timestamp field's value. +func (s *StartingPosition) SetTimestamp(v time.Time) *StartingPosition { + s.Timestamp = &v + return s +} + +// SetType sets the Type field's value. +func (s *StartingPosition) SetType(v string) *StartingPosition { + s.Type = &v + return s +} + +type StopStreamEncryptionInput struct { + _ struct{} `type:"structure"` + + // The encryption type. The only valid value is KMS. + // + // EncryptionType is a required field + EncryptionType *string `type:"string" required:"true" enum:"EncryptionType"` + + // The GUID for the customer-managed AWS KMS key to use for encryption. This + // value can be a globally unique identifier, a fully specified Amazon Resource + // Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You + // can also use a master key owned by Kinesis Data Streams by specifying the + // alias aws/kinesis. + // + // * Key ARN example: arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012 + // + // * Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName + // + // * Globally unique key ID example: 12345678-1234-1234-1234-123456789012 + // + // * Alias name example: alias/MyAliasName + // + // * Master key owned by Kinesis Data Streams: alias/aws/kinesis + // + // KeyId is a required field + KeyId *string `min:"1" type:"string" required:"true"` + + // The name of the stream on which to stop encrypting records. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` +} + +// String returns the string representation +func (s StopStreamEncryptionInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StopStreamEncryptionInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *StopStreamEncryptionInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "StopStreamEncryptionInput"} + if s.EncryptionType == nil { + invalidParams.Add(request.NewErrParamRequired("EncryptionType")) + } + if s.KeyId == nil { + invalidParams.Add(request.NewErrParamRequired("KeyId")) + } + if s.KeyId != nil && len(*s.KeyId) < 1 { + invalidParams.Add(request.NewErrParamMinLen("KeyId", 1)) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetEncryptionType sets the EncryptionType field's value. +func (s *StopStreamEncryptionInput) SetEncryptionType(v string) *StopStreamEncryptionInput { + s.EncryptionType = &v + return s +} + +// SetKeyId sets the KeyId field's value. +func (s *StopStreamEncryptionInput) SetKeyId(v string) *StopStreamEncryptionInput { + s.KeyId = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *StopStreamEncryptionInput) SetStreamName(v string) *StopStreamEncryptionInput { + s.StreamName = &v + return s +} + +type StopStreamEncryptionOutput struct { + _ struct{} `type:"structure"` +} + +// String returns the string representation +func (s StopStreamEncryptionOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StopStreamEncryptionOutput) GoString() string { + return s.String() +} + +// Represents the output for DescribeStream. +type StreamDescription struct { + _ struct{} `type:"structure"` + + // The server-side encryption type used on the stream. This parameter can be + // one of the following values: + // + // * NONE: Do not encrypt the records in the stream. + // + // * KMS: Use server-side encryption on the records in the stream using a + // customer-managed AWS KMS key. + EncryptionType *string `type:"string" enum:"EncryptionType"` + + // Represents the current enhanced monitoring settings of the stream. + // + // EnhancedMonitoring is a required field + EnhancedMonitoring []*EnhancedMetrics `type:"list" required:"true"` + + // If set to true, more shards in the stream are available to describe. + // + // HasMoreShards is a required field + HasMoreShards *bool `type:"boolean" required:"true"` + + // The GUID for the customer-managed AWS KMS key to use for encryption. This + // value can be a globally unique identifier, a fully specified ARN to either + // an alias or a key, or an alias name prefixed by "alias/".You can also use + // a master key owned by Kinesis Data Streams by specifying the alias aws/kinesis. + // + // * Key ARN example: arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012 + // + // * Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName + // + // * Globally unique key ID example: 12345678-1234-1234-1234-123456789012 + // + // * Alias name example: alias/MyAliasName + // + // * Master key owned by Kinesis Data Streams: alias/aws/kinesis + KeyId *string `min:"1" type:"string"` + + // The current retention period, in hours. Minimum value of 24. Maximum value + // of 168. + // + // RetentionPeriodHours is a required field + RetentionPeriodHours *int64 `type:"integer" required:"true"` + + // The shards that comprise the stream. + // + // Shards is a required field + Shards []*Shard `type:"list" required:"true"` + + // The Amazon Resource Name (ARN) for the stream being described. + // + // StreamARN is a required field + StreamARN *string `min:"1" type:"string" required:"true"` + + // The approximate time that the stream was created. + // + // StreamCreationTimestamp is a required field + StreamCreationTimestamp *time.Time `type:"timestamp" required:"true"` + + // The name of the stream being described. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` + + // The current status of the stream being described. The stream status is one + // of the following states: + // + // * CREATING - The stream is being created. Kinesis Data Streams immediately + // returns and sets StreamStatus to CREATING. + // + // * DELETING - The stream is being deleted. The specified stream is in the + // DELETING state until Kinesis Data Streams completes the deletion. + // + // * ACTIVE - The stream exists and is ready for read and write operations + // or deletion. You should perform read and write operations only on an ACTIVE + // stream. + // + // * UPDATING - Shards in the stream are being merged or split. Read and + // write operations continue to work while the stream is in the UPDATING + // state. + // + // StreamStatus is a required field + StreamStatus *string `type:"string" required:"true" enum:"StreamStatus"` +} + +// String returns the string representation +func (s StreamDescription) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StreamDescription) GoString() string { + return s.String() +} + +// SetEncryptionType sets the EncryptionType field's value. +func (s *StreamDescription) SetEncryptionType(v string) *StreamDescription { + s.EncryptionType = &v + return s +} + +// SetEnhancedMonitoring sets the EnhancedMonitoring field's value. +func (s *StreamDescription) SetEnhancedMonitoring(v []*EnhancedMetrics) *StreamDescription { + s.EnhancedMonitoring = v + return s +} + +// SetHasMoreShards sets the HasMoreShards field's value. +func (s *StreamDescription) SetHasMoreShards(v bool) *StreamDescription { + s.HasMoreShards = &v + return s +} + +// SetKeyId sets the KeyId field's value. +func (s *StreamDescription) SetKeyId(v string) *StreamDescription { + s.KeyId = &v + return s +} + +// SetRetentionPeriodHours sets the RetentionPeriodHours field's value. +func (s *StreamDescription) SetRetentionPeriodHours(v int64) *StreamDescription { + s.RetentionPeriodHours = &v + return s +} + +// SetShards sets the Shards field's value. +func (s *StreamDescription) SetShards(v []*Shard) *StreamDescription { + s.Shards = v + return s +} + +// SetStreamARN sets the StreamARN field's value. +func (s *StreamDescription) SetStreamARN(v string) *StreamDescription { + s.StreamARN = &v + return s +} + +// SetStreamCreationTimestamp sets the StreamCreationTimestamp field's value. +func (s *StreamDescription) SetStreamCreationTimestamp(v time.Time) *StreamDescription { + s.StreamCreationTimestamp = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *StreamDescription) SetStreamName(v string) *StreamDescription { + s.StreamName = &v + return s +} + +// SetStreamStatus sets the StreamStatus field's value. +func (s *StreamDescription) SetStreamStatus(v string) *StreamDescription { + s.StreamStatus = &v + return s +} + +// Represents the output for DescribeStreamSummary +type StreamDescriptionSummary struct { + _ struct{} `type:"structure"` + + // The number of enhanced fan-out consumers registered with the stream. + ConsumerCount *int64 `type:"integer"` + + // The encryption type used. This value is one of the following: + // + // * KMS + // + // * NONE + EncryptionType *string `type:"string" enum:"EncryptionType"` + + // Represents the current enhanced monitoring settings of the stream. + // + // EnhancedMonitoring is a required field + EnhancedMonitoring []*EnhancedMetrics `type:"list" required:"true"` + + // The GUID for the customer-managed AWS KMS key to use for encryption. This + // value can be a globally unique identifier, a fully specified ARN to either + // an alias or a key, or an alias name prefixed by "alias/".You can also use + // a master key owned by Kinesis Data Streams by specifying the alias aws/kinesis. + // + // * Key ARN example: arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012 + // + // * Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName + // + // * Globally unique key ID example: 12345678-1234-1234-1234-123456789012 + // + // * Alias name example: alias/MyAliasName + // + // * Master key owned by Kinesis Data Streams: alias/aws/kinesis + KeyId *string `min:"1" type:"string"` + + // The number of open shards in the stream. + // + // OpenShardCount is a required field + OpenShardCount *int64 `type:"integer" required:"true"` + + // The current retention period, in hours. + // + // RetentionPeriodHours is a required field + RetentionPeriodHours *int64 `type:"integer" required:"true"` + + // The Amazon Resource Name (ARN) for the stream being described. + // + // StreamARN is a required field + StreamARN *string `min:"1" type:"string" required:"true"` + + // The approximate time that the stream was created. + // + // StreamCreationTimestamp is a required field + StreamCreationTimestamp *time.Time `type:"timestamp" required:"true"` + + // The name of the stream being described. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` + + // The current status of the stream being described. The stream status is one + // of the following states: + // + // * CREATING - The stream is being created. Kinesis Data Streams immediately + // returns and sets StreamStatus to CREATING. + // + // * DELETING - The stream is being deleted. The specified stream is in the + // DELETING state until Kinesis Data Streams completes the deletion. + // + // * ACTIVE - The stream exists and is ready for read and write operations + // or deletion. You should perform read and write operations only on an ACTIVE + // stream. + // + // * UPDATING - Shards in the stream are being merged or split. Read and + // write operations continue to work while the stream is in the UPDATING + // state. + // + // StreamStatus is a required field + StreamStatus *string `type:"string" required:"true" enum:"StreamStatus"` +} + +// String returns the string representation +func (s StreamDescriptionSummary) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s StreamDescriptionSummary) GoString() string { + return s.String() +} + +// SetConsumerCount sets the ConsumerCount field's value. +func (s *StreamDescriptionSummary) SetConsumerCount(v int64) *StreamDescriptionSummary { + s.ConsumerCount = &v + return s +} + +// SetEncryptionType sets the EncryptionType field's value. +func (s *StreamDescriptionSummary) SetEncryptionType(v string) *StreamDescriptionSummary { + s.EncryptionType = &v + return s +} + +// SetEnhancedMonitoring sets the EnhancedMonitoring field's value. +func (s *StreamDescriptionSummary) SetEnhancedMonitoring(v []*EnhancedMetrics) *StreamDescriptionSummary { + s.EnhancedMonitoring = v + return s +} + +// SetKeyId sets the KeyId field's value. +func (s *StreamDescriptionSummary) SetKeyId(v string) *StreamDescriptionSummary { + s.KeyId = &v + return s +} + +// SetOpenShardCount sets the OpenShardCount field's value. +func (s *StreamDescriptionSummary) SetOpenShardCount(v int64) *StreamDescriptionSummary { + s.OpenShardCount = &v + return s +} + +// SetRetentionPeriodHours sets the RetentionPeriodHours field's value. +func (s *StreamDescriptionSummary) SetRetentionPeriodHours(v int64) *StreamDescriptionSummary { + s.RetentionPeriodHours = &v + return s +} + +// SetStreamARN sets the StreamARN field's value. +func (s *StreamDescriptionSummary) SetStreamARN(v string) *StreamDescriptionSummary { + s.StreamARN = &v + return s +} + +// SetStreamCreationTimestamp sets the StreamCreationTimestamp field's value. +func (s *StreamDescriptionSummary) SetStreamCreationTimestamp(v time.Time) *StreamDescriptionSummary { + s.StreamCreationTimestamp = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *StreamDescriptionSummary) SetStreamName(v string) *StreamDescriptionSummary { + s.StreamName = &v + return s +} + +// SetStreamStatus sets the StreamStatus field's value. +func (s *StreamDescriptionSummary) SetStreamStatus(v string) *StreamDescriptionSummary { + s.StreamStatus = &v + return s +} + +// After you call SubscribeToShard, Kinesis Data Streams sends events of this +// type over an HTTP/2 connection to your consumer. +type SubscribeToShardEvent struct { + _ struct{} `type:"structure"` + + ChildShards []*ChildShard `type:"list"` + + // Use this as SequenceNumber in the next call to SubscribeToShard, with StartingPosition + // set to AT_SEQUENCE_NUMBER or AFTER_SEQUENCE_NUMBER. Use ContinuationSequenceNumber + // for checkpointing because it captures your shard progress even when no data + // is written to the shard. + // + // ContinuationSequenceNumber is a required field + ContinuationSequenceNumber *string `type:"string" required:"true"` + + // The number of milliseconds the read records are from the tip of the stream, + // indicating how far behind current time the consumer is. A value of zero indicates + // that record processing is caught up, and there are no new records to process + // at this moment. + // + // MillisBehindLatest is a required field + MillisBehindLatest *int64 `type:"long" required:"true"` + + // Records is a required field + Records []*Record `type:"list" required:"true"` +} + +// String returns the string representation +func (s SubscribeToShardEvent) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SubscribeToShardEvent) GoString() string { + return s.String() +} + +// SetChildShards sets the ChildShards field's value. +func (s *SubscribeToShardEvent) SetChildShards(v []*ChildShard) *SubscribeToShardEvent { + s.ChildShards = v + return s +} + +// SetContinuationSequenceNumber sets the ContinuationSequenceNumber field's value. +func (s *SubscribeToShardEvent) SetContinuationSequenceNumber(v string) *SubscribeToShardEvent { + s.ContinuationSequenceNumber = &v + return s +} + +// SetMillisBehindLatest sets the MillisBehindLatest field's value. +func (s *SubscribeToShardEvent) SetMillisBehindLatest(v int64) *SubscribeToShardEvent { + s.MillisBehindLatest = &v + return s +} + +// SetRecords sets the Records field's value. +func (s *SubscribeToShardEvent) SetRecords(v []*Record) *SubscribeToShardEvent { + s.Records = v + return s +} + +// The SubscribeToShardEvent is and event in the SubscribeToShardEventStream group of events. +func (s *SubscribeToShardEvent) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the SubscribeToShardEvent value. +// This method is only used internally within the SDK's EventStream handling. +func (s *SubscribeToShardEvent) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *SubscribeToShardEvent) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.EventMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +// SubscribeToShardEventStreamEvent groups together all EventStream +// events writes for SubscribeToShardEventStream. +// +// These events are: +// +// * SubscribeToShardEvent +type SubscribeToShardEventStreamEvent interface { + eventSubscribeToShardEventStream() + eventstreamapi.Marshaler + eventstreamapi.Unmarshaler +} + +// SubscribeToShardEventStreamReader provides the interface for reading to the stream. The +// default implementation for this interface will be SubscribeToShardEventStreamData. +// +// The reader's Close method must allow multiple concurrent calls. +// +// These events are: +// +// * SubscribeToShardEvent +// * SubscribeToShardEventStreamUnknownEvent +type SubscribeToShardEventStreamReader interface { + // Returns a channel of events as they are read from the event stream. + Events() <-chan SubscribeToShardEventStreamEvent + + // Close will stop the reader reading events from the stream. + Close() error + + // Returns any error that has occurred while reading from the event stream. + Err() error +} + +type readSubscribeToShardEventStream struct { + eventReader *eventstreamapi.EventReader + stream chan SubscribeToShardEventStreamEvent + err *eventstreamapi.OnceError + + done chan struct{} + closeOnce sync.Once +} + +func newReadSubscribeToShardEventStream(eventReader *eventstreamapi.EventReader) *readSubscribeToShardEventStream { + r := &readSubscribeToShardEventStream{ + eventReader: eventReader, + stream: make(chan SubscribeToShardEventStreamEvent), + done: make(chan struct{}), + err: eventstreamapi.NewOnceError(), + } + go r.readEventStream() + + return r +} + +// Close will close the underlying event stream reader. +func (r *readSubscribeToShardEventStream) Close() error { + r.closeOnce.Do(r.safeClose) + return r.Err() +} + +func (r *readSubscribeToShardEventStream) ErrorSet() <-chan struct{} { + return r.err.ErrorSet() +} + +func (r *readSubscribeToShardEventStream) Closed() <-chan struct{} { + return r.done +} + +func (r *readSubscribeToShardEventStream) safeClose() { + close(r.done) +} + +func (r *readSubscribeToShardEventStream) Err() error { + return r.err.Err() +} + +func (r *readSubscribeToShardEventStream) Events() <-chan SubscribeToShardEventStreamEvent { + return r.stream +} + +func (r *readSubscribeToShardEventStream) readEventStream() { + defer r.Close() + defer close(r.stream) + + for { + event, err := r.eventReader.ReadEvent() + if err != nil { + if err == io.EOF { + return + } + select { + case <-r.done: + // If closed already ignore the error + return + default: + } + if _, ok := err.(*eventstreamapi.UnknownMessageTypeError); ok { + continue + } + r.err.SetError(err) + return + } + + select { + case r.stream <- event.(SubscribeToShardEventStreamEvent): + case <-r.done: + return + } + } +} + +type unmarshalerForSubscribeToShardEventStreamEvent struct { + metadata protocol.ResponseMetadata +} + +func (u unmarshalerForSubscribeToShardEventStreamEvent) UnmarshalerForEventName(eventType string) (eventstreamapi.Unmarshaler, error) { + switch eventType { + case "SubscribeToShardEvent": + return &SubscribeToShardEvent{}, nil + case "InternalFailureException": + return newErrorInternalFailureException(u.metadata).(eventstreamapi.Unmarshaler), nil + case "KMSAccessDeniedException": + return newErrorKMSAccessDeniedException(u.metadata).(eventstreamapi.Unmarshaler), nil + case "KMSDisabledException": + return newErrorKMSDisabledException(u.metadata).(eventstreamapi.Unmarshaler), nil + case "KMSInvalidStateException": + return newErrorKMSInvalidStateException(u.metadata).(eventstreamapi.Unmarshaler), nil + case "KMSNotFoundException": + return newErrorKMSNotFoundException(u.metadata).(eventstreamapi.Unmarshaler), nil + case "KMSOptInRequired": + return newErrorKMSOptInRequired(u.metadata).(eventstreamapi.Unmarshaler), nil + case "KMSThrottlingException": + return newErrorKMSThrottlingException(u.metadata).(eventstreamapi.Unmarshaler), nil + case "ResourceInUseException": + return newErrorResourceInUseException(u.metadata).(eventstreamapi.Unmarshaler), nil + case "ResourceNotFoundException": + return newErrorResourceNotFoundException(u.metadata).(eventstreamapi.Unmarshaler), nil + default: + return &SubscribeToShardEventStreamUnknownEvent{Type: eventType}, nil + } +} + +// SubscribeToShardEventStreamUnknownEvent provides a failsafe event for the +// SubscribeToShardEventStream group of events when an unknown event is received. +type SubscribeToShardEventStreamUnknownEvent struct { + Type string + Message eventstream.Message +} + +// The SubscribeToShardEventStreamUnknownEvent is and event in the SubscribeToShardEventStream +// group of events. +func (s *SubscribeToShardEventStreamUnknownEvent) eventSubscribeToShardEventStream() {} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (e *SubscribeToShardEventStreamUnknownEvent) MarshalEvent(pm protocol.PayloadMarshaler) ( + msg eventstream.Message, err error, +) { + return e.Message.Clone(), nil +} + +// UnmarshalEvent unmarshals the EventStream Message into the SubscribeToShardEventStreamData value. +// This method is only used internally within the SDK's EventStream handling. +func (e *SubscribeToShardEventStreamUnknownEvent) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + e.Message = msg.Clone() + return nil +} + +type SubscribeToShardInput struct { + _ struct{} `type:"structure"` + + // For this parameter, use the value you obtained when you called RegisterStreamConsumer. + // + // ConsumerARN is a required field + ConsumerARN *string `min:"1" type:"string" required:"true"` + + // The ID of the shard you want to subscribe to. To see a list of all the shards + // for a given stream, use ListShards. + // + // ShardId is a required field + ShardId *string `min:"1" type:"string" required:"true"` + + // StartingPosition is a required field + StartingPosition *StartingPosition `type:"structure" required:"true"` +} + +// String returns the string representation +func (s SubscribeToShardInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SubscribeToShardInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *SubscribeToShardInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "SubscribeToShardInput"} + if s.ConsumerARN == nil { + invalidParams.Add(request.NewErrParamRequired("ConsumerARN")) + } + if s.ConsumerARN != nil && len(*s.ConsumerARN) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ConsumerARN", 1)) + } + if s.ShardId == nil { + invalidParams.Add(request.NewErrParamRequired("ShardId")) + } + if s.ShardId != nil && len(*s.ShardId) < 1 { + invalidParams.Add(request.NewErrParamMinLen("ShardId", 1)) + } + if s.StartingPosition == nil { + invalidParams.Add(request.NewErrParamRequired("StartingPosition")) + } + if s.StartingPosition != nil { + if err := s.StartingPosition.Validate(); err != nil { + invalidParams.AddNested("StartingPosition", err.(request.ErrInvalidParams)) + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetConsumerARN sets the ConsumerARN field's value. +func (s *SubscribeToShardInput) SetConsumerARN(v string) *SubscribeToShardInput { + s.ConsumerARN = &v + return s +} + +// SetShardId sets the ShardId field's value. +func (s *SubscribeToShardInput) SetShardId(v string) *SubscribeToShardInput { + s.ShardId = &v + return s +} + +// SetStartingPosition sets the StartingPosition field's value. +func (s *SubscribeToShardInput) SetStartingPosition(v *StartingPosition) *SubscribeToShardInput { + s.StartingPosition = v + return s +} + +type SubscribeToShardOutput struct { + _ struct{} `type:"structure"` + + EventStream *SubscribeToShardEventStream +} + +// String returns the string representation +func (s SubscribeToShardOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s SubscribeToShardOutput) GoString() string { + return s.String() +} + +func (s *SubscribeToShardOutput) SetEventStream(v *SubscribeToShardEventStream) *SubscribeToShardOutput { + s.EventStream = v + return s +} +func (s *SubscribeToShardOutput) GetEventStream() *SubscribeToShardEventStream { + return s.EventStream +} + +// GetStream returns the type to interact with the event stream. +func (s *SubscribeToShardOutput) GetStream() *SubscribeToShardEventStream { + return s.EventStream +} + +// The SubscribeToShardOutput is and event in the SubscribeToShardEventStream group of events. +func (s *SubscribeToShardOutput) eventSubscribeToShardEventStream() {} + +// UnmarshalEvent unmarshals the EventStream Message into the SubscribeToShardOutput value. +// This method is only used internally within the SDK's EventStream handling. +func (s *SubscribeToShardOutput) UnmarshalEvent( + payloadUnmarshaler protocol.PayloadUnmarshaler, + msg eventstream.Message, +) error { + if err := payloadUnmarshaler.UnmarshalPayload( + bytes.NewReader(msg.Payload), s, + ); err != nil { + return err + } + return nil +} + +// MarshalEvent marshals the type into an stream event value. This method +// should only used internally within the SDK's EventStream handling. +func (s *SubscribeToShardOutput) MarshalEvent(pm protocol.PayloadMarshaler) (msg eventstream.Message, err error) { + msg.Headers.Set(eventstreamapi.MessageTypeHeader, eventstream.StringValue(eventstreamapi.EventMessageType)) + var buf bytes.Buffer + if err = pm.MarshalPayload(&buf, s); err != nil { + return eventstream.Message{}, err + } + msg.Payload = buf.Bytes() + return msg, err +} + +// Metadata assigned to the stream, consisting of a key-value pair. +type Tag struct { + _ struct{} `type:"structure"` + + // A unique identifier for the tag. Maximum length: 128 characters. Valid characters: + // Unicode letters, digits, white space, _ . / = + - % @ + // + // Key is a required field + Key *string `min:"1" type:"string" required:"true"` + + // An optional string, typically used to describe or define the tag. Maximum + // length: 256 characters. Valid characters: Unicode letters, digits, white + // space, _ . / = + - % @ + Value *string `type:"string"` +} + +// String returns the string representation +func (s Tag) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Tag) GoString() string { + return s.String() +} + +// SetKey sets the Key field's value. +func (s *Tag) SetKey(v string) *Tag { + s.Key = &v + return s +} + +// SetValue sets the Value field's value. +func (s *Tag) SetValue(v string) *Tag { + s.Value = &v + return s +} + +type UpdateShardCountInput struct { + _ struct{} `type:"structure"` + + // The scaling type. Uniform scaling creates shards of equal size. + // + // ScalingType is a required field + ScalingType *string `type:"string" required:"true" enum:"ScalingType"` + + // The name of the stream. + // + // StreamName is a required field + StreamName *string `min:"1" type:"string" required:"true"` + + // The new number of shards. This value has the following default limits. By + // default, you cannot do the following: + // + // * Set this value to more than double your current shard count for a stream. + // + // * Set this value below half your current shard count for a stream. + // + // * Set this value to more than 500 shards in a stream (the default limit + // for shard count per stream is 500 per account per region), unless you + // request a limit increase. + // + // * Scale a stream with more than 500 shards down unless you set this value + // to less than 500 shards. + // + // TargetShardCount is a required field + TargetShardCount *int64 `min:"1" type:"integer" required:"true"` +} + +// String returns the string representation +func (s UpdateShardCountInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateShardCountInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *UpdateShardCountInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "UpdateShardCountInput"} + if s.ScalingType == nil { + invalidParams.Add(request.NewErrParamRequired("ScalingType")) + } + if s.StreamName == nil { + invalidParams.Add(request.NewErrParamRequired("StreamName")) + } + if s.StreamName != nil && len(*s.StreamName) < 1 { + invalidParams.Add(request.NewErrParamMinLen("StreamName", 1)) + } + if s.TargetShardCount == nil { + invalidParams.Add(request.NewErrParamRequired("TargetShardCount")) + } + if s.TargetShardCount != nil && *s.TargetShardCount < 1 { + invalidParams.Add(request.NewErrParamMinValue("TargetShardCount", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetScalingType sets the ScalingType field's value. +func (s *UpdateShardCountInput) SetScalingType(v string) *UpdateShardCountInput { + s.ScalingType = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *UpdateShardCountInput) SetStreamName(v string) *UpdateShardCountInput { + s.StreamName = &v + return s +} + +// SetTargetShardCount sets the TargetShardCount field's value. +func (s *UpdateShardCountInput) SetTargetShardCount(v int64) *UpdateShardCountInput { + s.TargetShardCount = &v + return s +} + +type UpdateShardCountOutput struct { + _ struct{} `type:"structure"` + + // The current number of shards. + CurrentShardCount *int64 `min:"1" type:"integer"` + + // The name of the stream. + StreamName *string `min:"1" type:"string"` + + // The updated number of shards. + TargetShardCount *int64 `min:"1" type:"integer"` +} + +// String returns the string representation +func (s UpdateShardCountOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s UpdateShardCountOutput) GoString() string { + return s.String() +} + +// SetCurrentShardCount sets the CurrentShardCount field's value. +func (s *UpdateShardCountOutput) SetCurrentShardCount(v int64) *UpdateShardCountOutput { + s.CurrentShardCount = &v + return s +} + +// SetStreamName sets the StreamName field's value. +func (s *UpdateShardCountOutput) SetStreamName(v string) *UpdateShardCountOutput { + s.StreamName = &v + return s +} + +// SetTargetShardCount sets the TargetShardCount field's value. +func (s *UpdateShardCountOutput) SetTargetShardCount(v int64) *UpdateShardCountOutput { + s.TargetShardCount = &v + return s +} + +const ( + // ConsumerStatusCreating is a ConsumerStatus enum value + ConsumerStatusCreating = "CREATING" + + // ConsumerStatusDeleting is a ConsumerStatus enum value + ConsumerStatusDeleting = "DELETING" + + // ConsumerStatusActive is a ConsumerStatus enum value + ConsumerStatusActive = "ACTIVE" +) + +// ConsumerStatus_Values returns all elements of the ConsumerStatus enum +func ConsumerStatus_Values() []string { + return []string{ + ConsumerStatusCreating, + ConsumerStatusDeleting, + ConsumerStatusActive, + } +} + +const ( + // EncryptionTypeNone is a EncryptionType enum value + EncryptionTypeNone = "NONE" + + // EncryptionTypeKms is a EncryptionType enum value + EncryptionTypeKms = "KMS" +) + +// EncryptionType_Values returns all elements of the EncryptionType enum +func EncryptionType_Values() []string { + return []string{ + EncryptionTypeNone, + EncryptionTypeKms, + } +} + +const ( + // MetricsNameIncomingBytes is a MetricsName enum value + MetricsNameIncomingBytes = "IncomingBytes" + + // MetricsNameIncomingRecords is a MetricsName enum value + MetricsNameIncomingRecords = "IncomingRecords" + + // MetricsNameOutgoingBytes is a MetricsName enum value + MetricsNameOutgoingBytes = "OutgoingBytes" + + // MetricsNameOutgoingRecords is a MetricsName enum value + MetricsNameOutgoingRecords = "OutgoingRecords" + + // MetricsNameWriteProvisionedThroughputExceeded is a MetricsName enum value + MetricsNameWriteProvisionedThroughputExceeded = "WriteProvisionedThroughputExceeded" + + // MetricsNameReadProvisionedThroughputExceeded is a MetricsName enum value + MetricsNameReadProvisionedThroughputExceeded = "ReadProvisionedThroughputExceeded" + + // MetricsNameIteratorAgeMilliseconds is a MetricsName enum value + MetricsNameIteratorAgeMilliseconds = "IteratorAgeMilliseconds" + + // MetricsNameAll is a MetricsName enum value + MetricsNameAll = "ALL" +) + +// MetricsName_Values returns all elements of the MetricsName enum +func MetricsName_Values() []string { + return []string{ + MetricsNameIncomingBytes, + MetricsNameIncomingRecords, + MetricsNameOutgoingBytes, + MetricsNameOutgoingRecords, + MetricsNameWriteProvisionedThroughputExceeded, + MetricsNameReadProvisionedThroughputExceeded, + MetricsNameIteratorAgeMilliseconds, + MetricsNameAll, + } +} + +const ( + // ScalingTypeUniformScaling is a ScalingType enum value + ScalingTypeUniformScaling = "UNIFORM_SCALING" +) + +// ScalingType_Values returns all elements of the ScalingType enum +func ScalingType_Values() []string { + return []string{ + ScalingTypeUniformScaling, + } +} + +const ( + // ShardFilterTypeAfterShardId is a ShardFilterType enum value + ShardFilterTypeAfterShardId = "AFTER_SHARD_ID" + + // ShardFilterTypeAtTrimHorizon is a ShardFilterType enum value + ShardFilterTypeAtTrimHorizon = "AT_TRIM_HORIZON" + + // ShardFilterTypeFromTrimHorizon is a ShardFilterType enum value + ShardFilterTypeFromTrimHorizon = "FROM_TRIM_HORIZON" + + // ShardFilterTypeAtLatest is a ShardFilterType enum value + ShardFilterTypeAtLatest = "AT_LATEST" + + // ShardFilterTypeAtTimestamp is a ShardFilterType enum value + ShardFilterTypeAtTimestamp = "AT_TIMESTAMP" + + // ShardFilterTypeFromTimestamp is a ShardFilterType enum value + ShardFilterTypeFromTimestamp = "FROM_TIMESTAMP" +) + +// ShardFilterType_Values returns all elements of the ShardFilterType enum +func ShardFilterType_Values() []string { + return []string{ + ShardFilterTypeAfterShardId, + ShardFilterTypeAtTrimHorizon, + ShardFilterTypeFromTrimHorizon, + ShardFilterTypeAtLatest, + ShardFilterTypeAtTimestamp, + ShardFilterTypeFromTimestamp, + } +} + +const ( + // ShardIteratorTypeAtSequenceNumber is a ShardIteratorType enum value + ShardIteratorTypeAtSequenceNumber = "AT_SEQUENCE_NUMBER" + + // ShardIteratorTypeAfterSequenceNumber is a ShardIteratorType enum value + ShardIteratorTypeAfterSequenceNumber = "AFTER_SEQUENCE_NUMBER" + + // ShardIteratorTypeTrimHorizon is a ShardIteratorType enum value + ShardIteratorTypeTrimHorizon = "TRIM_HORIZON" + + // ShardIteratorTypeLatest is a ShardIteratorType enum value + ShardIteratorTypeLatest = "LATEST" + + // ShardIteratorTypeAtTimestamp is a ShardIteratorType enum value + ShardIteratorTypeAtTimestamp = "AT_TIMESTAMP" +) + +// ShardIteratorType_Values returns all elements of the ShardIteratorType enum +func ShardIteratorType_Values() []string { + return []string{ + ShardIteratorTypeAtSequenceNumber, + ShardIteratorTypeAfterSequenceNumber, + ShardIteratorTypeTrimHorizon, + ShardIteratorTypeLatest, + ShardIteratorTypeAtTimestamp, + } +} + +const ( + // StreamStatusCreating is a StreamStatus enum value + StreamStatusCreating = "CREATING" + + // StreamStatusDeleting is a StreamStatus enum value + StreamStatusDeleting = "DELETING" + + // StreamStatusActive is a StreamStatus enum value + StreamStatusActive = "ACTIVE" + + // StreamStatusUpdating is a StreamStatus enum value + StreamStatusUpdating = "UPDATING" +) + +// StreamStatus_Values returns all elements of the StreamStatus enum +func StreamStatus_Values() []string { + return []string{ + StreamStatusCreating, + StreamStatusDeleting, + StreamStatusActive, + StreamStatusUpdating, + } +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/kinesis/customizations.go b/vendor/github.com/aws/aws-sdk-go/service/kinesis/customizations.go new file mode 100644 index 00000000..0ab63673 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/kinesis/customizations.go @@ -0,0 +1,22 @@ +package kinesis + +import ( + "time" + + "github.com/aws/aws-sdk-go/aws/request" +) + +var readDuration = 5 * time.Second + +func init() { + initRequest = customizeRequest +} + +func customizeRequest(r *request.Request) { + if r.Operation.Name == opGetRecords { + r.ApplyOptions(request.WithResponseReadTimeout(readDuration)) + } + + // Service specific error codes. Github(aws/aws-sdk-go#1376) + r.RetryErrorCodes = append(r.RetryErrorCodes, ErrCodeLimitExceededException) +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/kinesis/doc.go b/vendor/github.com/aws/aws-sdk-go/service/kinesis/doc.go new file mode 100644 index 00000000..06e8de5f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/kinesis/doc.go @@ -0,0 +1,29 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +// Package kinesis provides the client and types for making API +// requests to Amazon Kinesis. +// +// Amazon Kinesis Data Streams is a managed service that scales elastically +// for real-time processing of streaming big data. +// +// See https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02 for more information on this service. +// +// See kinesis package documentation for more information. +// https://docs.aws.amazon.com/sdk-for-go/api/service/kinesis/ +// +// Using the Client +// +// To contact Amazon Kinesis with the SDK use the New function to create +// a new service client. With that client you can make API requests to the service. +// These clients are safe to use concurrently. +// +// See the SDK's documentation for more information on how to use the SDK. +// https://docs.aws.amazon.com/sdk-for-go/api/ +// +// See aws.Config documentation for more information on configuring SDK clients. +// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config +// +// See the Amazon Kinesis client Kinesis for more +// information on creating client for this service. +// https://docs.aws.amazon.com/sdk-for-go/api/service/kinesis/#New +package kinesis diff --git a/vendor/github.com/aws/aws-sdk-go/service/kinesis/errors.go b/vendor/github.com/aws/aws-sdk-go/service/kinesis/errors.go new file mode 100644 index 00000000..da7880ee --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/kinesis/errors.go @@ -0,0 +1,129 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package kinesis + +import ( + "github.com/aws/aws-sdk-go/private/protocol" +) + +const ( + + // ErrCodeExpiredIteratorException for service response error code + // "ExpiredIteratorException". + // + // The provided iterator exceeds the maximum age allowed. + ErrCodeExpiredIteratorException = "ExpiredIteratorException" + + // ErrCodeExpiredNextTokenException for service response error code + // "ExpiredNextTokenException". + // + // The pagination token passed to the operation is expired. + ErrCodeExpiredNextTokenException = "ExpiredNextTokenException" + + // ErrCodeInternalFailureException for service response error code + // "InternalFailureException". + // + // The processing of the request failed because of an unknown error, exception, + // or failure. + ErrCodeInternalFailureException = "InternalFailureException" + + // ErrCodeInvalidArgumentException for service response error code + // "InvalidArgumentException". + // + // A specified parameter exceeds its restrictions, is not supported, or can't + // be used. For more information, see the returned message. + ErrCodeInvalidArgumentException = "InvalidArgumentException" + + // ErrCodeKMSAccessDeniedException for service response error code + // "KMSAccessDeniedException". + // + // The ciphertext references a key that doesn't exist or that you don't have + // access to. + ErrCodeKMSAccessDeniedException = "KMSAccessDeniedException" + + // ErrCodeKMSDisabledException for service response error code + // "KMSDisabledException". + // + // The request was rejected because the specified customer master key (CMK) + // isn't enabled. + ErrCodeKMSDisabledException = "KMSDisabledException" + + // ErrCodeKMSInvalidStateException for service response error code + // "KMSInvalidStateException". + // + // 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 (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html) + // in the AWS Key Management Service Developer Guide. + ErrCodeKMSInvalidStateException = "KMSInvalidStateException" + + // ErrCodeKMSNotFoundException for service response error code + // "KMSNotFoundException". + // + // The request was rejected because the specified entity or resource can't be + // found. + ErrCodeKMSNotFoundException = "KMSNotFoundException" + + // ErrCodeKMSOptInRequired for service response error code + // "KMSOptInRequired". + // + // The AWS access key ID needs a subscription for the service. + ErrCodeKMSOptInRequired = "KMSOptInRequired" + + // ErrCodeKMSThrottlingException for service response error code + // "KMSThrottlingException". + // + // The request was denied due to request throttling. For more information about + // throttling, see Limits (https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) + // in the AWS Key Management Service Developer Guide. + ErrCodeKMSThrottlingException = "KMSThrottlingException" + + // ErrCodeLimitExceededException for service response error code + // "LimitExceededException". + // + // The requested resource exceeds the maximum number allowed, or the number + // of concurrent stream requests exceeds the maximum number allowed. + ErrCodeLimitExceededException = "LimitExceededException" + + // ErrCodeProvisionedThroughputExceededException for service response error code + // "ProvisionedThroughputExceededException". + // + // 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html) + // in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and + // Exponential Backoff in AWS (https://docs.aws.amazon.com/general/latest/gr/api-retries.html) + // in the AWS General Reference. + ErrCodeProvisionedThroughputExceededException = "ProvisionedThroughputExceededException" + + // ErrCodeResourceInUseException for service response error code + // "ResourceInUseException". + // + // The resource is not available for this operation. For successful operation, + // the resource must be in the ACTIVE state. + ErrCodeResourceInUseException = "ResourceInUseException" + + // ErrCodeResourceNotFoundException for service response error code + // "ResourceNotFoundException". + // + // The requested resource could not be found. The stream might not be specified + // correctly. + ErrCodeResourceNotFoundException = "ResourceNotFoundException" +) + +var exceptionFromCode = map[string]func(protocol.ResponseMetadata) error{ + "ExpiredIteratorException": newErrorExpiredIteratorException, + "ExpiredNextTokenException": newErrorExpiredNextTokenException, + "InternalFailureException": newErrorInternalFailureException, + "InvalidArgumentException": newErrorInvalidArgumentException, + "KMSAccessDeniedException": newErrorKMSAccessDeniedException, + "KMSDisabledException": newErrorKMSDisabledException, + "KMSInvalidStateException": newErrorKMSInvalidStateException, + "KMSNotFoundException": newErrorKMSNotFoundException, + "KMSOptInRequired": newErrorKMSOptInRequired, + "KMSThrottlingException": newErrorKMSThrottlingException, + "LimitExceededException": newErrorLimitExceededException, + "ProvisionedThroughputExceededException": newErrorProvisionedThroughputExceededException, + "ResourceInUseException": newErrorResourceInUseException, + "ResourceNotFoundException": newErrorResourceNotFoundException, +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/kinesis/kinesisiface/interface.go b/vendor/github.com/aws/aws-sdk-go/service/kinesis/kinesisiface/interface.go new file mode 100644 index 00000000..7c0b834b --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/kinesis/kinesisiface/interface.go @@ -0,0 +1,191 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +// Package kinesisiface provides an interface to enable mocking the Amazon Kinesis service client +// for testing your code. +// +// It is important to note that this interface will have breaking changes +// when the service model is updated and adds new API operations, paginators, +// and waiters. +package kinesisiface + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/kinesis" +) + +// KinesisAPI provides an interface to enable mocking the +// kinesis.Kinesis service client's API operation, +// paginators, and waiters. This make unit testing your code that calls out +// to the SDK's service client's calls easier. +// +// The best way to use this interface is so the SDK's service client's calls +// can be stubbed out for unit testing your code with the SDK without needing +// to inject custom request handlers into the SDK's request pipeline. +// +// // myFunc uses an SDK service client to make a request to +// // Amazon Kinesis. +// func myFunc(svc kinesisiface.KinesisAPI) bool { +// // Make svc.AddTagsToStream request +// } +// +// func main() { +// sess := session.New() +// svc := kinesis.New(sess) +// +// myFunc(svc) +// } +// +// In your _test.go file: +// +// // Define a mock struct to be used in your unit tests of myFunc. +// type mockKinesisClient struct { +// kinesisiface.KinesisAPI +// } +// func (m *mockKinesisClient) AddTagsToStream(input *kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error) { +// // mock response/functionality +// } +// +// func TestMyFunc(t *testing.T) { +// // Setup Test +// mockSvc := &mockKinesisClient{} +// +// myfunc(mockSvc) +// +// // Verify myFunc's functionality +// } +// +// It is important to note that this interface will have breaking changes +// when the service model is updated and adds new API operations, paginators, +// and waiters. Its suggested to use the pattern above for testing, or using +// tooling to generate mocks to satisfy the interfaces. +type KinesisAPI interface { + AddTagsToStream(*kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error) + AddTagsToStreamWithContext(aws.Context, *kinesis.AddTagsToStreamInput, ...request.Option) (*kinesis.AddTagsToStreamOutput, error) + AddTagsToStreamRequest(*kinesis.AddTagsToStreamInput) (*request.Request, *kinesis.AddTagsToStreamOutput) + + CreateStream(*kinesis.CreateStreamInput) (*kinesis.CreateStreamOutput, error) + CreateStreamWithContext(aws.Context, *kinesis.CreateStreamInput, ...request.Option) (*kinesis.CreateStreamOutput, error) + CreateStreamRequest(*kinesis.CreateStreamInput) (*request.Request, *kinesis.CreateStreamOutput) + + DecreaseStreamRetentionPeriod(*kinesis.DecreaseStreamRetentionPeriodInput) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) + DecreaseStreamRetentionPeriodWithContext(aws.Context, *kinesis.DecreaseStreamRetentionPeriodInput, ...request.Option) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) + DecreaseStreamRetentionPeriodRequest(*kinesis.DecreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.DecreaseStreamRetentionPeriodOutput) + + DeleteStream(*kinesis.DeleteStreamInput) (*kinesis.DeleteStreamOutput, error) + DeleteStreamWithContext(aws.Context, *kinesis.DeleteStreamInput, ...request.Option) (*kinesis.DeleteStreamOutput, error) + DeleteStreamRequest(*kinesis.DeleteStreamInput) (*request.Request, *kinesis.DeleteStreamOutput) + + DeregisterStreamConsumer(*kinesis.DeregisterStreamConsumerInput) (*kinesis.DeregisterStreamConsumerOutput, error) + DeregisterStreamConsumerWithContext(aws.Context, *kinesis.DeregisterStreamConsumerInput, ...request.Option) (*kinesis.DeregisterStreamConsumerOutput, error) + DeregisterStreamConsumerRequest(*kinesis.DeregisterStreamConsumerInput) (*request.Request, *kinesis.DeregisterStreamConsumerOutput) + + DescribeLimits(*kinesis.DescribeLimitsInput) (*kinesis.DescribeLimitsOutput, error) + DescribeLimitsWithContext(aws.Context, *kinesis.DescribeLimitsInput, ...request.Option) (*kinesis.DescribeLimitsOutput, error) + DescribeLimitsRequest(*kinesis.DescribeLimitsInput) (*request.Request, *kinesis.DescribeLimitsOutput) + + DescribeStream(*kinesis.DescribeStreamInput) (*kinesis.DescribeStreamOutput, error) + DescribeStreamWithContext(aws.Context, *kinesis.DescribeStreamInput, ...request.Option) (*kinesis.DescribeStreamOutput, error) + DescribeStreamRequest(*kinesis.DescribeStreamInput) (*request.Request, *kinesis.DescribeStreamOutput) + + DescribeStreamPages(*kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool) error + DescribeStreamPagesWithContext(aws.Context, *kinesis.DescribeStreamInput, func(*kinesis.DescribeStreamOutput, bool) bool, ...request.Option) error + + DescribeStreamConsumer(*kinesis.DescribeStreamConsumerInput) (*kinesis.DescribeStreamConsumerOutput, error) + DescribeStreamConsumerWithContext(aws.Context, *kinesis.DescribeStreamConsumerInput, ...request.Option) (*kinesis.DescribeStreamConsumerOutput, error) + DescribeStreamConsumerRequest(*kinesis.DescribeStreamConsumerInput) (*request.Request, *kinesis.DescribeStreamConsumerOutput) + + DescribeStreamSummary(*kinesis.DescribeStreamSummaryInput) (*kinesis.DescribeStreamSummaryOutput, error) + DescribeStreamSummaryWithContext(aws.Context, *kinesis.DescribeStreamSummaryInput, ...request.Option) (*kinesis.DescribeStreamSummaryOutput, error) + DescribeStreamSummaryRequest(*kinesis.DescribeStreamSummaryInput) (*request.Request, *kinesis.DescribeStreamSummaryOutput) + + DisableEnhancedMonitoring(*kinesis.DisableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) + DisableEnhancedMonitoringWithContext(aws.Context, *kinesis.DisableEnhancedMonitoringInput, ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) + DisableEnhancedMonitoringRequest(*kinesis.DisableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) + + EnableEnhancedMonitoring(*kinesis.EnableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) + EnableEnhancedMonitoringWithContext(aws.Context, *kinesis.EnableEnhancedMonitoringInput, ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) + EnableEnhancedMonitoringRequest(*kinesis.EnableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) + + GetRecords(*kinesis.GetRecordsInput) (*kinesis.GetRecordsOutput, error) + GetRecordsWithContext(aws.Context, *kinesis.GetRecordsInput, ...request.Option) (*kinesis.GetRecordsOutput, error) + GetRecordsRequest(*kinesis.GetRecordsInput) (*request.Request, *kinesis.GetRecordsOutput) + + GetShardIterator(*kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error) + GetShardIteratorWithContext(aws.Context, *kinesis.GetShardIteratorInput, ...request.Option) (*kinesis.GetShardIteratorOutput, error) + GetShardIteratorRequest(*kinesis.GetShardIteratorInput) (*request.Request, *kinesis.GetShardIteratorOutput) + + IncreaseStreamRetentionPeriod(*kinesis.IncreaseStreamRetentionPeriodInput) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) + IncreaseStreamRetentionPeriodWithContext(aws.Context, *kinesis.IncreaseStreamRetentionPeriodInput, ...request.Option) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) + IncreaseStreamRetentionPeriodRequest(*kinesis.IncreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.IncreaseStreamRetentionPeriodOutput) + + ListShards(*kinesis.ListShardsInput) (*kinesis.ListShardsOutput, error) + ListShardsWithContext(aws.Context, *kinesis.ListShardsInput, ...request.Option) (*kinesis.ListShardsOutput, error) + ListShardsRequest(*kinesis.ListShardsInput) (*request.Request, *kinesis.ListShardsOutput) + + ListStreamConsumers(*kinesis.ListStreamConsumersInput) (*kinesis.ListStreamConsumersOutput, error) + ListStreamConsumersWithContext(aws.Context, *kinesis.ListStreamConsumersInput, ...request.Option) (*kinesis.ListStreamConsumersOutput, error) + ListStreamConsumersRequest(*kinesis.ListStreamConsumersInput) (*request.Request, *kinesis.ListStreamConsumersOutput) + + ListStreamConsumersPages(*kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool) error + ListStreamConsumersPagesWithContext(aws.Context, *kinesis.ListStreamConsumersInput, func(*kinesis.ListStreamConsumersOutput, bool) bool, ...request.Option) error + + ListStreams(*kinesis.ListStreamsInput) (*kinesis.ListStreamsOutput, error) + ListStreamsWithContext(aws.Context, *kinesis.ListStreamsInput, ...request.Option) (*kinesis.ListStreamsOutput, error) + ListStreamsRequest(*kinesis.ListStreamsInput) (*request.Request, *kinesis.ListStreamsOutput) + + ListStreamsPages(*kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool) error + ListStreamsPagesWithContext(aws.Context, *kinesis.ListStreamsInput, func(*kinesis.ListStreamsOutput, bool) bool, ...request.Option) error + + ListTagsForStream(*kinesis.ListTagsForStreamInput) (*kinesis.ListTagsForStreamOutput, error) + ListTagsForStreamWithContext(aws.Context, *kinesis.ListTagsForStreamInput, ...request.Option) (*kinesis.ListTagsForStreamOutput, error) + ListTagsForStreamRequest(*kinesis.ListTagsForStreamInput) (*request.Request, *kinesis.ListTagsForStreamOutput) + + MergeShards(*kinesis.MergeShardsInput) (*kinesis.MergeShardsOutput, error) + MergeShardsWithContext(aws.Context, *kinesis.MergeShardsInput, ...request.Option) (*kinesis.MergeShardsOutput, error) + MergeShardsRequest(*kinesis.MergeShardsInput) (*request.Request, *kinesis.MergeShardsOutput) + + PutRecord(*kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) + PutRecordWithContext(aws.Context, *kinesis.PutRecordInput, ...request.Option) (*kinesis.PutRecordOutput, error) + PutRecordRequest(*kinesis.PutRecordInput) (*request.Request, *kinesis.PutRecordOutput) + + PutRecords(*kinesis.PutRecordsInput) (*kinesis.PutRecordsOutput, error) + PutRecordsWithContext(aws.Context, *kinesis.PutRecordsInput, ...request.Option) (*kinesis.PutRecordsOutput, error) + PutRecordsRequest(*kinesis.PutRecordsInput) (*request.Request, *kinesis.PutRecordsOutput) + + RegisterStreamConsumer(*kinesis.RegisterStreamConsumerInput) (*kinesis.RegisterStreamConsumerOutput, error) + RegisterStreamConsumerWithContext(aws.Context, *kinesis.RegisterStreamConsumerInput, ...request.Option) (*kinesis.RegisterStreamConsumerOutput, error) + RegisterStreamConsumerRequest(*kinesis.RegisterStreamConsumerInput) (*request.Request, *kinesis.RegisterStreamConsumerOutput) + + RemoveTagsFromStream(*kinesis.RemoveTagsFromStreamInput) (*kinesis.RemoveTagsFromStreamOutput, error) + RemoveTagsFromStreamWithContext(aws.Context, *kinesis.RemoveTagsFromStreamInput, ...request.Option) (*kinesis.RemoveTagsFromStreamOutput, error) + RemoveTagsFromStreamRequest(*kinesis.RemoveTagsFromStreamInput) (*request.Request, *kinesis.RemoveTagsFromStreamOutput) + + SplitShard(*kinesis.SplitShardInput) (*kinesis.SplitShardOutput, error) + SplitShardWithContext(aws.Context, *kinesis.SplitShardInput, ...request.Option) (*kinesis.SplitShardOutput, error) + SplitShardRequest(*kinesis.SplitShardInput) (*request.Request, *kinesis.SplitShardOutput) + + StartStreamEncryption(*kinesis.StartStreamEncryptionInput) (*kinesis.StartStreamEncryptionOutput, error) + StartStreamEncryptionWithContext(aws.Context, *kinesis.StartStreamEncryptionInput, ...request.Option) (*kinesis.StartStreamEncryptionOutput, error) + StartStreamEncryptionRequest(*kinesis.StartStreamEncryptionInput) (*request.Request, *kinesis.StartStreamEncryptionOutput) + + StopStreamEncryption(*kinesis.StopStreamEncryptionInput) (*kinesis.StopStreamEncryptionOutput, error) + StopStreamEncryptionWithContext(aws.Context, *kinesis.StopStreamEncryptionInput, ...request.Option) (*kinesis.StopStreamEncryptionOutput, error) + StopStreamEncryptionRequest(*kinesis.StopStreamEncryptionInput) (*request.Request, *kinesis.StopStreamEncryptionOutput) + + SubscribeToShard(*kinesis.SubscribeToShardInput) (*kinesis.SubscribeToShardOutput, error) + SubscribeToShardWithContext(aws.Context, *kinesis.SubscribeToShardInput, ...request.Option) (*kinesis.SubscribeToShardOutput, error) + SubscribeToShardRequest(*kinesis.SubscribeToShardInput) (*request.Request, *kinesis.SubscribeToShardOutput) + + UpdateShardCount(*kinesis.UpdateShardCountInput) (*kinesis.UpdateShardCountOutput, error) + UpdateShardCountWithContext(aws.Context, *kinesis.UpdateShardCountInput, ...request.Option) (*kinesis.UpdateShardCountOutput, error) + UpdateShardCountRequest(*kinesis.UpdateShardCountInput) (*request.Request, *kinesis.UpdateShardCountOutput) + + WaitUntilStreamExists(*kinesis.DescribeStreamInput) error + WaitUntilStreamExistsWithContext(aws.Context, *kinesis.DescribeStreamInput, ...request.WaiterOption) error + + WaitUntilStreamNotExists(*kinesis.DescribeStreamInput) error + WaitUntilStreamNotExistsWithContext(aws.Context, *kinesis.DescribeStreamInput, ...request.WaiterOption) error +} + +var _ KinesisAPI = (*kinesis.Kinesis)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go/service/kinesis/service.go b/vendor/github.com/aws/aws-sdk-go/service/kinesis/service.go new file mode 100644 index 00000000..71f51b32 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/kinesis/service.go @@ -0,0 +1,106 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package kinesis + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/client" + "github.com/aws/aws-sdk-go/aws/client/metadata" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/aws/signer/v4" + "github.com/aws/aws-sdk-go/private/protocol" + "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" +) + +// Kinesis provides the API operation methods for making requests to +// Amazon Kinesis. See this package's package overview docs +// for details on the service. +// +// Kinesis methods are safe to use concurrently. It is not safe to +// modify mutate any of the struct's properties though. +type Kinesis struct { + *client.Client +} + +// Used for custom client initialization logic +var initClient func(*client.Client) + +// Used for custom request initialization logic +var initRequest func(*request.Request) + +// Service information constants +const ( + ServiceName = "kinesis" // Name of service. + EndpointsID = ServiceName // ID to lookup a service endpoint with. + ServiceID = "Kinesis" // ServiceID is a unique identifier of a specific service. +) + +// New creates a new instance of the Kinesis client with a session. +// If additional configuration is needed for the client instance use the optional +// aws.Config parameter to add your extra config. +// +// Example: +// mySession := session.Must(session.NewSession()) +// +// // Create a Kinesis client from just a session. +// svc := kinesis.New(mySession) +// +// // Create a Kinesis client with additional configuration +// svc := kinesis.New(mySession, aws.NewConfig().WithRegion("us-west-2")) +func New(p client.ConfigProvider, cfgs ...*aws.Config) *Kinesis { + c := p.ClientConfig(EndpointsID, cfgs...) + return newClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName) +} + +// newClient creates, initializes and returns a new service client instance. +func newClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName string) *Kinesis { + svc := &Kinesis{ + Client: client.New( + cfg, + metadata.ClientInfo{ + ServiceName: ServiceName, + ServiceID: ServiceID, + SigningName: signingName, + SigningRegion: signingRegion, + PartitionID: partitionID, + Endpoint: endpoint, + APIVersion: "2013-12-02", + JSONVersion: "1.1", + TargetPrefix: "Kinesis_20131202", + }, + handlers, + ), + } + + // Handlers + svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) + svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) + svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) + svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) + svc.Handlers.UnmarshalError.PushBackNamed( + protocol.NewUnmarshalErrorHandler(jsonrpc.NewUnmarshalTypedError(exceptionFromCode)).NamedHandler(), + ) + + svc.Handlers.BuildStream.PushBackNamed(jsonrpc.BuildHandler) + svc.Handlers.UnmarshalStream.PushBackNamed(jsonrpc.UnmarshalHandler) + + // Run custom client initialization if present + if initClient != nil { + initClient(svc.Client) + } + + return svc +} + +// newRequest creates a new request for a Kinesis operation and runs any +// custom request initialization. +func (c *Kinesis) newRequest(op *request.Operation, params, data interface{}) *request.Request { + req := c.NewRequest(op, params, data) + + // Run custom request initialization if present + if initRequest != nil { + initRequest(req) + } + + return req +} diff --git a/vendor/github.com/aws/aws-sdk-go/service/kinesis/waiters.go b/vendor/github.com/aws/aws-sdk-go/service/kinesis/waiters.go new file mode 100644 index 00000000..a51912ab --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/kinesis/waiters.go @@ -0,0 +1,102 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package kinesis + +import ( + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/request" +) + +// WaitUntilStreamExists uses the Kinesis API operation +// DescribeStream to wait for a condition to be met before returning. +// If the condition is not met within the max attempt window, an error will +// be returned. +func (c *Kinesis) WaitUntilStreamExists(input *DescribeStreamInput) error { + return c.WaitUntilStreamExistsWithContext(aws.BackgroundContext(), input) +} + +// WaitUntilStreamExistsWithContext is an extended version of WaitUntilStreamExists. +// With the support for passing in a context and options to configure the +// Waiter and the underlying request options. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) WaitUntilStreamExistsWithContext(ctx aws.Context, input *DescribeStreamInput, opts ...request.WaiterOption) error { + w := request.Waiter{ + Name: "WaitUntilStreamExists", + MaxAttempts: 18, + Delay: request.ConstantWaiterDelay(10 * time.Second), + Acceptors: []request.WaiterAcceptor{ + { + State: request.SuccessWaiterState, + Matcher: request.PathWaiterMatch, Argument: "StreamDescription.StreamStatus", + Expected: "ACTIVE", + }, + }, + Logger: c.Config.Logger, + NewRequest: func(opts []request.Option) (*request.Request, error) { + var inCpy *DescribeStreamInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.DescribeStreamRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + w.ApplyOptions(opts...) + + return w.WaitWithContext(ctx) +} + +// WaitUntilStreamNotExists uses the Kinesis API operation +// DescribeStream to wait for a condition to be met before returning. +// If the condition is not met within the max attempt window, an error will +// be returned. +func (c *Kinesis) WaitUntilStreamNotExists(input *DescribeStreamInput) error { + return c.WaitUntilStreamNotExistsWithContext(aws.BackgroundContext(), input) +} + +// WaitUntilStreamNotExistsWithContext is an extended version of WaitUntilStreamNotExists. +// With the support for passing in a context and options to configure the +// Waiter and the underlying request options. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Kinesis) WaitUntilStreamNotExistsWithContext(ctx aws.Context, input *DescribeStreamInput, opts ...request.WaiterOption) error { + w := request.Waiter{ + Name: "WaitUntilStreamNotExists", + MaxAttempts: 18, + Delay: request.ConstantWaiterDelay(10 * time.Second), + Acceptors: []request.WaiterAcceptor{ + { + State: request.SuccessWaiterState, + Matcher: request.ErrorWaiterMatch, + Expected: "ResourceNotFoundException", + }, + }, + Logger: c.Config.Logger, + NewRequest: func(opts []request.Option) (*request.Request, error) { + var inCpy *DescribeStreamInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.DescribeStreamRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + w.ApplyOptions(opts...) + + return w.WaitWithContext(ctx) +} diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/args/ps_args_aws_kinesis.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/args/ps_args_aws_kinesis.pb.go new file mode 100644 index 00000000..ec7807d6 --- /dev/null +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/args/ps_args_aws_kinesis.pb.go @@ -0,0 +1,280 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: ps_args_aws_kinesis.proto + +package args + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type AWSKinesisConn struct { + // @gotags: kong:"env=AWS_DEFAULT_REGION,hidden,required" + AwsRegion string `protobuf:"bytes,1,opt,name=aws_region,json=awsRegion,proto3" json:"aws_region,omitempty" kong:"env=AWS_DEFAULT_REGION,hidden,required"` + // @gotags: kong:"env=AWS_ACCESS_KEY_ID,hidden,required" + AwsAccessKeyId string `protobuf:"bytes,2,opt,name=aws_access_key_id,json=awsAccessKeyId,proto3" json:"aws_access_key_id,omitempty" kong:"env=AWS_ACCESS_KEY_ID,hidden,required"` + // @gotags: kong:"env=AWS_SECRET_ACCESS_KEY,hidden,required" + AwsSecretAccessKey string `protobuf:"bytes,3,opt,name=aws_secret_access_key,json=awsSecretAccessKey,proto3" json:"aws_secret_access_key,omitempty" kong:"env=AWS_SECRET_ACCESS_KEY,hidden,required"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AWSKinesisConn) Reset() { *m = AWSKinesisConn{} } +func (m *AWSKinesisConn) String() string { return proto.CompactTextString(m) } +func (*AWSKinesisConn) ProtoMessage() {} +func (*AWSKinesisConn) Descriptor() ([]byte, []int) { + return fileDescriptor_7f353884fb0804cc, []int{0} +} + +func (m *AWSKinesisConn) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AWSKinesisConn.Unmarshal(m, b) +} +func (m *AWSKinesisConn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AWSKinesisConn.Marshal(b, m, deterministic) +} +func (m *AWSKinesisConn) XXX_Merge(src proto.Message) { + xxx_messageInfo_AWSKinesisConn.Merge(m, src) +} +func (m *AWSKinesisConn) XXX_Size() int { + return xxx_messageInfo_AWSKinesisConn.Size(m) +} +func (m *AWSKinesisConn) XXX_DiscardUnknown() { + xxx_messageInfo_AWSKinesisConn.DiscardUnknown(m) +} + +var xxx_messageInfo_AWSKinesisConn proto.InternalMessageInfo + +func (m *AWSKinesisConn) GetAwsRegion() string { + if m != nil { + return m.AwsRegion + } + return "" +} + +func (m *AWSKinesisConn) GetAwsAccessKeyId() string { + if m != nil { + return m.AwsAccessKeyId + } + return "" +} + +func (m *AWSKinesisConn) GetAwsSecretAccessKey() string { + if m != nil { + return m.AwsSecretAccessKey + } + return "" +} + +type AWSKinesisReadArgs struct { + // @gotags: kong:"help='Stream Name',required" + Stream string `protobuf:"bytes,1,opt,name=stream,proto3" json:"stream,omitempty" kong:"help='Stream Name',required"` + // @gotags: kong:"help='Shard ID. If empty, will read from all shards'" + Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty" kong:"help='Shard ID. If empty, will read from all shards'"` + // @gotags: kong:"help='Maximum number of records to read from kinesis',default=1" + MaxRecords int64 `protobuf:"varint,3,opt,name=max_records,json=maxRecords,proto3" json:"max_records,omitempty" kong:"help='Maximum number of records to read from kinesis',default=1"` + // @gotags: kong:"help='Deliver starting at this timestamp',xor=kinesis_delivery_option" + ReadFromTimestamp int64 `protobuf:"varint,4,opt,name=read_from_timestamp,json=readFromTimestamp,proto3" json:"read_from_timestamp,omitempty" kong:"help='Deliver starting at this timestamp',xor=kinesis_delivery_option"` + // @gotags: kong:"help='Deliver messages starting at sequence number',xor=kinesis_delivery_option" + ReadSequenceNumber string `protobuf:"bytes,5,opt,name=read_sequence_number,json=readSequenceNumber,proto3" json:"read_sequence_number,omitempty" kong:"help='Deliver messages starting at sequence number',xor=kinesis_delivery_option"` + // @gotags: kong:"help='Deliver messages starting after this sequence number',xor=kinesis_delivery_option" + ReadAfterSequenceNumber string `protobuf:"bytes,6,opt,name=read_after_sequence_number,json=readAfterSequenceNumber,proto3" json:"read_after_sequence_number,omitempty" kong:"help='Deliver messages starting after this sequence number',xor=kinesis_delivery_option"` + // @gotags: kong:"help='Deliver messages starting at the last untrimmed record in the shard in the system, which is the oldest data record in the shard.',xor=kinesis_delivery_option" + ReadTrimHorizon bool `protobuf:"varint,7,opt,name=read_trim_horizon,json=readTrimHorizon,proto3" json:"read_trim_horizon,omitempty" kong:"help='Deliver messages starting at the last untrimmed record in the shard in the system, which is the oldest data record in the shard.',xor=kinesis_delivery_option"` + // @gotags: kong:"help='Deliver messages after the most recent record',xor=kinesis_delivery_option" + ReadLatest bool `protobuf:"varint,8,opt,name=read_latest,json=readLatest,proto3" json:"read_latest,omitempty" kong:"help='Deliver messages after the most recent record',xor=kinesis_delivery_option"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AWSKinesisReadArgs) Reset() { *m = AWSKinesisReadArgs{} } +func (m *AWSKinesisReadArgs) String() string { return proto.CompactTextString(m) } +func (*AWSKinesisReadArgs) ProtoMessage() {} +func (*AWSKinesisReadArgs) Descriptor() ([]byte, []int) { + return fileDescriptor_7f353884fb0804cc, []int{1} +} + +func (m *AWSKinesisReadArgs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AWSKinesisReadArgs.Unmarshal(m, b) +} +func (m *AWSKinesisReadArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AWSKinesisReadArgs.Marshal(b, m, deterministic) +} +func (m *AWSKinesisReadArgs) XXX_Merge(src proto.Message) { + xxx_messageInfo_AWSKinesisReadArgs.Merge(m, src) +} +func (m *AWSKinesisReadArgs) XXX_Size() int { + return xxx_messageInfo_AWSKinesisReadArgs.Size(m) +} +func (m *AWSKinesisReadArgs) XXX_DiscardUnknown() { + xxx_messageInfo_AWSKinesisReadArgs.DiscardUnknown(m) +} + +var xxx_messageInfo_AWSKinesisReadArgs proto.InternalMessageInfo + +func (m *AWSKinesisReadArgs) GetStream() string { + if m != nil { + return m.Stream + } + return "" +} + +func (m *AWSKinesisReadArgs) GetShard() string { + if m != nil { + return m.Shard + } + return "" +} + +func (m *AWSKinesisReadArgs) GetMaxRecords() int64 { + if m != nil { + return m.MaxRecords + } + return 0 +} + +func (m *AWSKinesisReadArgs) GetReadFromTimestamp() int64 { + if m != nil { + return m.ReadFromTimestamp + } + return 0 +} + +func (m *AWSKinesisReadArgs) GetReadSequenceNumber() string { + if m != nil { + return m.ReadSequenceNumber + } + return "" +} + +func (m *AWSKinesisReadArgs) GetReadAfterSequenceNumber() string { + if m != nil { + return m.ReadAfterSequenceNumber + } + return "" +} + +func (m *AWSKinesisReadArgs) GetReadTrimHorizon() bool { + if m != nil { + return m.ReadTrimHorizon + } + return false +} + +func (m *AWSKinesisReadArgs) GetReadLatest() bool { + if m != nil { + return m.ReadLatest + } + return false +} + +type AWSKinesisWriteArgs struct { + // @gotags: kong:"help='Stream Name',required" + Stream string `protobuf:"bytes,1,opt,name=stream,proto3" json:"stream,omitempty" kong:"help='Stream Name',required"` + // @gotags: kong:"help='Partition Key',required" + PartitionKey string `protobuf:"bytes,2,opt,name=partition_key,json=partitionKey,proto3" json:"partition_key,omitempty" kong:"help='Partition Key',required"` + // @gotags: kong:"help='Sequence number for ordering'" + SequenceNumber string `protobuf:"bytes,3,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty" kong:"help='Sequence number for ordering'"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AWSKinesisWriteArgs) Reset() { *m = AWSKinesisWriteArgs{} } +func (m *AWSKinesisWriteArgs) String() string { return proto.CompactTextString(m) } +func (*AWSKinesisWriteArgs) ProtoMessage() {} +func (*AWSKinesisWriteArgs) Descriptor() ([]byte, []int) { + return fileDescriptor_7f353884fb0804cc, []int{2} +} + +func (m *AWSKinesisWriteArgs) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AWSKinesisWriteArgs.Unmarshal(m, b) +} +func (m *AWSKinesisWriteArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AWSKinesisWriteArgs.Marshal(b, m, deterministic) +} +func (m *AWSKinesisWriteArgs) XXX_Merge(src proto.Message) { + xxx_messageInfo_AWSKinesisWriteArgs.Merge(m, src) +} +func (m *AWSKinesisWriteArgs) XXX_Size() int { + return xxx_messageInfo_AWSKinesisWriteArgs.Size(m) +} +func (m *AWSKinesisWriteArgs) XXX_DiscardUnknown() { + xxx_messageInfo_AWSKinesisWriteArgs.DiscardUnknown(m) +} + +var xxx_messageInfo_AWSKinesisWriteArgs proto.InternalMessageInfo + +func (m *AWSKinesisWriteArgs) GetStream() string { + if m != nil { + return m.Stream + } + return "" +} + +func (m *AWSKinesisWriteArgs) GetPartitionKey() string { + if m != nil { + return m.PartitionKey + } + return "" +} + +func (m *AWSKinesisWriteArgs) GetSequenceNumber() string { + if m != nil { + return m.SequenceNumber + } + return "" +} + +func init() { + proto.RegisterType((*AWSKinesisConn)(nil), "protos.args.AWSKinesisConn") + proto.RegisterType((*AWSKinesisReadArgs)(nil), "protos.args.AWSKinesisReadArgs") + proto.RegisterType((*AWSKinesisWriteArgs)(nil), "protos.args.AWSKinesisWriteArgs") +} + +func init() { proto.RegisterFile("ps_args_aws_kinesis.proto", fileDescriptor_7f353884fb0804cc) } + +var fileDescriptor_7f353884fb0804cc = []byte{ + // 438 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0x51, 0x6b, 0x13, 0x41, + 0x10, 0xc7, 0x49, 0x6b, 0x63, 0x3b, 0xd5, 0x94, 0x6e, 0xab, 0x9e, 0x82, 0x58, 0xe2, 0x83, 0x55, + 0x30, 0xa7, 0xf8, 0x24, 0x7d, 0x8a, 0x82, 0x28, 0x11, 0x1f, 0x2e, 0x85, 0x82, 0x2f, 0xcb, 0xde, + 0xdd, 0xf4, 0x6e, 0x69, 0xf6, 0xf6, 0x9c, 0xd9, 0x90, 0x46, 0x3f, 0x83, 0x9f, 0xcd, 0xaf, 0x24, + 0x3b, 0x97, 0xb6, 0x1a, 0xc1, 0xa7, 0x63, 0xfe, 0xff, 0xdf, 0x9f, 0x9b, 0x99, 0x1d, 0x78, 0xd8, + 0xb2, 0x36, 0x54, 0xb1, 0x36, 0x0b, 0xd6, 0x17, 0xb6, 0x41, 0xb6, 0x3c, 0x6a, 0xc9, 0x07, 0xaf, + 0x76, 0xe5, 0xc3, 0xa3, 0x68, 0x0f, 0x7f, 0xf6, 0x60, 0x30, 0x3e, 0x9b, 0x4e, 0x3a, 0xe2, 0xbd, + 0x6f, 0x1a, 0xf5, 0x18, 0x20, 0x86, 0x08, 0x2b, 0xeb, 0x9b, 0xa4, 0x77, 0xd4, 0x3b, 0xde, 0xc9, + 0x76, 0xcc, 0x82, 0x33, 0x11, 0xd4, 0x73, 0xd8, 0x8f, 0xb6, 0x29, 0x0a, 0x64, 0xd6, 0x17, 0xb8, + 0xd4, 0xb6, 0x4c, 0x36, 0x84, 0x1a, 0x98, 0x05, 0x8f, 0x45, 0x9f, 0xe0, 0xf2, 0x53, 0xa9, 0x5e, + 0xc3, 0xbd, 0x88, 0x32, 0x16, 0x84, 0xe1, 0x8f, 0x44, 0xb2, 0x29, 0xb8, 0x32, 0x0b, 0x9e, 0x8a, + 0x77, 0x1d, 0x1a, 0xfe, 0xda, 0x00, 0x75, 0xd3, 0x4f, 0x86, 0xa6, 0x1c, 0x53, 0xc5, 0xea, 0x3e, + 0xf4, 0x39, 0x10, 0x1a, 0xb7, 0xea, 0x67, 0x55, 0xa9, 0x43, 0xd8, 0xe2, 0xda, 0xd0, 0x55, 0x03, + 0x5d, 0xa1, 0x9e, 0xc0, 0xae, 0x33, 0x97, 0x9a, 0xb0, 0xf0, 0x54, 0xb2, 0xfc, 0x6d, 0x33, 0x03, + 0x67, 0x2e, 0xb3, 0x4e, 0x51, 0x23, 0x38, 0x20, 0x34, 0xa5, 0x3e, 0x27, 0xef, 0x74, 0xb0, 0x0e, + 0x39, 0x18, 0xd7, 0x26, 0xb7, 0x04, 0xdc, 0x8f, 0xd6, 0x07, 0xf2, 0xee, 0xf4, 0xca, 0x50, 0xaf, + 0xe0, 0x50, 0x78, 0xc6, 0x6f, 0x73, 0x6c, 0x0a, 0xd4, 0xcd, 0xdc, 0xe5, 0x48, 0xc9, 0x56, 0x37, + 0x47, 0xf4, 0xa6, 0x2b, 0xeb, 0x8b, 0x38, 0xea, 0x04, 0x1e, 0x49, 0xc2, 0x9c, 0x07, 0xa4, 0x7f, + 0x72, 0x7d, 0xc9, 0x3d, 0x88, 0xc4, 0x38, 0x02, 0x6b, 0xe1, 0x17, 0x20, 0x3d, 0xe8, 0x40, 0xd6, + 0xe9, 0xda, 0x93, 0xfd, 0xee, 0x9b, 0xe4, 0xf6, 0x51, 0xef, 0x78, 0x3b, 0xdb, 0x8b, 0xc6, 0x29, + 0x59, 0xf7, 0xb1, 0x93, 0xe3, 0xac, 0xc2, 0xce, 0x4c, 0x40, 0x0e, 0xc9, 0xb6, 0x50, 0x10, 0xa5, + 0xcf, 0xa2, 0x0c, 0x7f, 0xc0, 0xc1, 0xcd, 0x42, 0xcf, 0xc8, 0x06, 0xfc, 0xef, 0x46, 0x9f, 0xc2, + 0xdd, 0xd6, 0x50, 0xb0, 0xc1, 0xfa, 0x46, 0xde, 0xaa, 0xdb, 0xec, 0x9d, 0x6b, 0x71, 0x82, 0x4b, + 0xf5, 0x0c, 0xf6, 0xd6, 0x47, 0xea, 0x9e, 0x74, 0xc0, 0x7f, 0x4d, 0xf2, 0xee, 0xe4, 0xeb, 0xdb, + 0xca, 0x86, 0x7a, 0x9e, 0x8f, 0x0a, 0xef, 0xd2, 0xdc, 0x84, 0xa2, 0x2e, 0x3c, 0xb5, 0x69, 0x3b, + 0x13, 0xff, 0x25, 0x17, 0x35, 0x3a, 0xc3, 0x69, 0x3e, 0xb7, 0xb3, 0x32, 0xad, 0x7c, 0xda, 0xdd, + 0x66, 0x1a, 0x6f, 0x33, 0xef, 0x4b, 0xf1, 0xe6, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2a, 0xdd, + 0x85, 0x1f, 0xcc, 0x02, 0x00, 0x00, +} diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/common/ps_common_backends.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/common/ps_common_backends.pb.go index 8287e084..fa980301 100644 --- a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/common/ps_common_backends.pb.go +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/common/ps_common_backends.pb.go @@ -43,6 +43,7 @@ const ( BackendType_BACKEND_TYPE_POSTGRES_CDC BackendType = 17 BackendType_BACKEND_TYPE_MONGODB_CDC BackendType = 18 BackendType_BACKEND_TYPE_KUBE_MQ BackendType = 19 + BackendType_BACKEND_TYPE_AWS_KINESIS BackendType = 20 ) var BackendType_name = map[int32]string{ @@ -66,6 +67,7 @@ var BackendType_name = map[int32]string{ 17: "BACKEND_TYPE_POSTGRES_CDC", 18: "BACKEND_TYPE_MONGODB_CDC", 19: "BACKEND_TYPE_KUBE_MQ", + 20: "BACKEND_TYPE_AWS_KINESIS", } var BackendType_value = map[string]int32{ @@ -89,6 +91,7 @@ var BackendType_value = map[string]int32{ "BACKEND_TYPE_POSTGRES_CDC": 17, "BACKEND_TYPE_MONGODB_CDC": 18, "BACKEND_TYPE_KUBE_MQ": 19, + "BACKEND_TYPE_AWS_KINESIS": 20, } func (x BackendType) String() string { @@ -106,29 +109,30 @@ func init() { func init() { proto.RegisterFile("ps_common_backends.proto", fileDescriptor_b7390f38ee25065b) } var fileDescriptor_b7390f38ee25065b = []byte{ - // 381 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x4f, 0x6f, 0xd3, 0x40, - 0x10, 0xc5, 0xf9, 0x53, 0x0a, 0x4c, 0x29, 0x4c, 0xa7, 0x2d, 0x4d, 0x69, 0x29, 0x88, 0x23, 0x12, - 0xf5, 0x81, 0x23, 0xe2, 0xb0, 0xeb, 0x2c, 0xc1, 0x32, 0x71, 0x6c, 0xcf, 0x6e, 0x10, 0xbd, 0xac, - 0x62, 0xd7, 0x6a, 0x2a, 0xea, 0xda, 0x8a, 0x93, 0x03, 0x1f, 0x8e, 0xef, 0x86, 0x12, 0x93, 0xc3, - 0xca, 0x3e, 0xad, 0xf6, 0xfd, 0xde, 0x3e, 0xcd, 0x3e, 0x0d, 0x0c, 0xea, 0xc6, 0xe6, 0x55, 0x59, - 0x56, 0xf7, 0x36, 0x9b, 0xe5, 0xbf, 0x8b, 0xfb, 0xeb, 0xe6, 0xb2, 0x5e, 0x54, 0xcb, 0x8a, 0xf6, - 0x37, 0x47, 0x73, 0xd9, 0xd2, 0x8f, 0x7f, 0x77, 0x60, 0x4f, 0xb6, 0x0e, 0xfd, 0xa7, 0x2e, 0xe8, - 0x35, 0x90, 0x14, 0x7e, 0xa8, 0xa2, 0xa1, 0xd5, 0xbf, 0x62, 0x65, 0x4d, 0xc4, 0x4a, 0xe3, 0x83, - 0x8e, 0x1e, 0x8a, 0x6f, 0xa1, 0xc0, 0x87, 0x74, 0x02, 0x87, 0x8e, 0x9e, 0x0a, 0x29, 0x03, 0x8d, - 0x8f, 0xe8, 0x1d, 0x9c, 0xf5, 0x00, 0xcb, 0x3a, 0x55, 0x62, 0xcc, 0xf8, 0x98, 0x8e, 0x00, 0x1d, - 0x43, 0xc4, 0x09, 0xee, 0xd0, 0x31, 0x1c, 0xb8, 0xaa, 0xd0, 0x8c, 0x4f, 0x3a, 0x69, 0x6b, 0xf9, - 0x7f, 0x56, 0x10, 0x8d, 0x70, 0x97, 0xce, 0xe0, 0xc4, 0x31, 0x8c, 0xfc, 0xd8, 0xc6, 0x46, 0xb2, - 0x91, 0xf8, 0x94, 0x3e, 0xc0, 0x85, 0x03, 0xc5, 0x95, 0x49, 0x95, 0x65, 0x95, 0x4e, 0x03, 0x5f, - 0x59, 0x69, 0x18, 0x9f, 0xd1, 0x7b, 0x38, 0xef, 0xf1, 0xa8, 0xa9, 0x8a, 0xb4, 0xfd, 0x6e, 0x24, - 0x3e, 0xa7, 0x01, 0x1c, 0xb9, 0x8e, 0x9f, 0x6c, 0x39, 0x61, 0x84, 0x7e, 0x12, 0x31, 0xee, 0xd1, - 0x5b, 0x38, 0x75, 0x5b, 0x50, 0xc3, 0x80, 0xb7, 0x83, 0xbd, 0xa0, 0x0b, 0x78, 0xd3, 0x83, 0xb7, - 0x1d, 0xed, 0xd3, 0x29, 0x1c, 0xbb, 0xc1, 0xbe, 0x0e, 0xa6, 0x6a, 0x9c, 0xe0, 0xcb, 0x4e, 0xf1, - 0xb1, 0xf9, 0xc1, 0x22, 0xc5, 0x57, 0x9d, 0x06, 0xc7, 0x89, 0xd6, 0x88, 0x9d, 0x49, 0xe2, 0x09, - 0xeb, 0x51, 0xaa, 0xd8, 0xfa, 0x43, 0x1f, 0x0f, 0xe8, 0x1c, 0x06, 0xee, 0xab, 0x49, 0x34, 0x9a, - 0x0c, 0xe5, 0x86, 0x52, 0xe7, 0x83, 0xa1, 0x91, 0xeb, 0x60, 0x3c, 0x94, 0x5f, 0xaf, 0xbe, 0xdc, - 0xdc, 0x2e, 0xe7, 0xab, 0x6c, 0xbd, 0x50, 0x5e, 0x36, 0x5b, 0xe6, 0xf3, 0xbc, 0x5a, 0xd4, 0x5e, - 0x7d, 0xb7, 0x2a, 0xb3, 0x62, 0xf1, 0xa9, 0xc9, 0xe7, 0x45, 0x39, 0x6b, 0xbc, 0x6c, 0x75, 0x7b, - 0x77, 0xed, 0xdd, 0x54, 0x5e, 0xbb, 0x7e, 0x5e, 0xbb, 0x7e, 0xd9, 0xee, 0xe6, 0xfa, 0xf9, 0x5f, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x6b, 0x3e, 0x34, 0xfa, 0xb0, 0x02, 0x00, 0x00, + // 390 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0x4d, 0x6f, 0xd3, 0x40, + 0x10, 0xe5, 0xa3, 0x14, 0x98, 0x52, 0x98, 0x4e, 0x53, 0x9a, 0xd2, 0x52, 0x10, 0x47, 0x24, 0xea, + 0x03, 0x47, 0xc4, 0x61, 0xd7, 0x59, 0x82, 0x65, 0xb2, 0x71, 0x3c, 0xbb, 0x41, 0xf4, 0xb2, 0x8a, + 0xdd, 0xa8, 0xa9, 0x68, 0x6a, 0x2b, 0x4e, 0x0e, 0xfc, 0x56, 0xfe, 0x0c, 0x72, 0x4c, 0x0f, 0x2b, + 0xfb, 0xb4, 0xda, 0xf7, 0xde, 0x3c, 0xcd, 0x3c, 0x3d, 0xe8, 0x97, 0x95, 0xcb, 0x8b, 0xe5, 0xb2, + 0xb8, 0x73, 0xd9, 0x2c, 0xff, 0x3d, 0xbf, 0xbb, 0xaa, 0x2e, 0xca, 0x55, 0xb1, 0x2e, 0x68, 0x7f, + 0xfb, 0x54, 0x17, 0x0d, 0xfb, 0xf1, 0xef, 0x0e, 0xec, 0xc9, 0x46, 0x61, 0xfe, 0x94, 0x73, 0x7a, + 0x0d, 0x24, 0x45, 0x18, 0x2b, 0x3d, 0x70, 0xe6, 0x57, 0xa2, 0x9c, 0xd5, 0xac, 0x0c, 0x3e, 0x68, + 0xe1, 0xb1, 0xf8, 0x16, 0x0b, 0x7c, 0x48, 0xc7, 0x70, 0xe8, 0xe1, 0xa9, 0x90, 0x32, 0x32, 0xf8, + 0x88, 0xde, 0xc1, 0x69, 0x07, 0xe1, 0xd8, 0xa4, 0x4a, 0x8c, 0x18, 0x1f, 0x53, 0x0f, 0xd0, 0x13, + 0x68, 0x9e, 0xe0, 0x0e, 0x1d, 0xc1, 0x81, 0x8f, 0x0a, 0xc3, 0xf8, 0xa4, 0xe5, 0x56, 0xc3, 0xff, + 0xbd, 0x22, 0x3d, 0xc4, 0x5d, 0x3a, 0x85, 0x63, 0x4f, 0x30, 0x0c, 0x13, 0x97, 0x58, 0xc9, 0x56, + 0xe2, 0x53, 0xfa, 0x00, 0xe7, 0x1e, 0x29, 0x2e, 0x6d, 0xaa, 0x1c, 0xab, 0x74, 0x1a, 0x85, 0xca, + 0x49, 0xcb, 0xf8, 0x8c, 0xde, 0xc3, 0x59, 0x87, 0x46, 0x4d, 0x95, 0x36, 0xee, 0xbb, 0x95, 0xf8, + 0x9c, 0xfa, 0xd0, 0xf3, 0x15, 0x3f, 0xd9, 0xf1, 0x84, 0x11, 0xba, 0x19, 0xcd, 0xb8, 0x47, 0x6f, + 0xe1, 0xc4, 0x4f, 0x41, 0x0d, 0x22, 0xbe, 0x5f, 0xec, 0x05, 0x9d, 0xc3, 0x9b, 0x0e, 0xfa, 0x3e, + 0xa3, 0x7d, 0x3a, 0x81, 0x23, 0xdf, 0x38, 0x34, 0xd1, 0x54, 0x8d, 0x26, 0xf8, 0xb2, 0x15, 0x7c, + 0x62, 0x7f, 0xb0, 0x48, 0xf1, 0x55, 0x2b, 0xc1, 0xd1, 0xc4, 0x18, 0xc4, 0xd6, 0x26, 0xc9, 0x98, + 0xcd, 0x30, 0x55, 0xec, 0xc2, 0x41, 0x88, 0x07, 0x74, 0x06, 0x7d, 0x7f, 0x6a, 0xac, 0x87, 0xe3, + 0x81, 0xdc, 0xb2, 0xd4, 0x3a, 0x30, 0xb6, 0xb2, 0x36, 0xc6, 0xc3, 0xd6, 0x5c, 0x7d, 0x7a, 0x1c, + 0x69, 0xc5, 0x11, 0x63, 0x4f, 0x7e, 0xbd, 0xfc, 0x72, 0x7d, 0xb3, 0x5e, 0x6c, 0xb2, 0xba, 0x6e, + 0x41, 0x36, 0x5b, 0xe7, 0x8b, 0xbc, 0x58, 0x95, 0x41, 0x79, 0xbb, 0x59, 0x66, 0xf3, 0xd5, 0xa7, + 0x2a, 0x5f, 0xcc, 0x97, 0xb3, 0x2a, 0xc8, 0x36, 0x37, 0xb7, 0x57, 0xc1, 0x75, 0x11, 0x34, 0xe5, + 0x0c, 0x9a, 0x72, 0x66, 0xbb, 0xdb, 0xef, 0xe7, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x60, 0xc3, + 0x1b, 0x9e, 0xce, 0x02, 0x00, 0x00, } diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/batch_connection_options.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/batch_connection_options.pb.go index ba43a3e5..5d1cd662 100644 --- a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/batch_connection_options.pb.go +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/batch_connection_options.pb.go @@ -8,23 +8,23 @@ import ( func GenerateConnOpts(backend string, connArgs interface{}) (IsConnectionOptions_Conn, bool) { switch backend { - case "pulsar": - asserted, ok := connArgs.(args.PulsarConn) + case "nats": + asserted, ok := connArgs.(args.NatsConn) if !ok { return nil, false } - return &ConnectionOptions_Pulsar{ - Pulsar: &asserted, + return &ConnectionOptions_Nats{ + Nats: &asserted, }, true - case "rabbit": - asserted, ok := connArgs.(args.RabbitConn) + case "postgres": + asserted, ok := connArgs.(args.PostgresConn) if !ok { return nil, false } - return &ConnectionOptions_Rabbit{ - Rabbit: &asserted, + return &ConnectionOptions_Postgres{ + Postgres: &asserted, }, true case "azureservicebus": asserted, ok := connArgs.(args.AzureServiceBusConn) @@ -35,59 +35,41 @@ func GenerateConnOpts(backend string, connArgs interface{}) (IsConnectionOptions return &ConnectionOptions_AzureServiceBus{ AzureServiceBus: &asserted, }, true - case "mqtt": - asserted, ok := connArgs.(args.MQTTConn) - if !ok { - return nil, false - } - - return &ConnectionOptions_Mqtt{ - Mqtt: &asserted, - }, true - case "awssqs": - asserted, ok := connArgs.(args.AWSSQSConn) - if !ok { - return nil, false - } - - return &ConnectionOptions_AwsSqs{ - AwsSqs: &asserted, - }, true - case "nsq": - asserted, ok := connArgs.(args.NSQConn) + case "gcppubsub": + asserted, ok := connArgs.(args.GCPPubSubConn) if !ok { return nil, false } - return &ConnectionOptions_Nsq{ - Nsq: &asserted, + return &ConnectionOptions_GcpPubsub{ + GcpPubsub: &asserted, }, true - case "nats": - asserted, ok := connArgs.(args.NatsConn) + case "natsjetstream": + asserted, ok := connArgs.(args.NatsJetstreamConn) if !ok { return nil, false } - return &ConnectionOptions_Nats{ - Nats: &asserted, + return &ConnectionOptions_NatsJetstream{ + NatsJetstream: &asserted, }, true - case "redisstreams": - asserted, ok := connArgs.(args.RedisStreamsConn) + case "kubemqqueue": + asserted, ok := connArgs.(args.KubeMQQueueConn) if !ok { return nil, false } - return &ConnectionOptions_RedisStreams{ - RedisStreams: &asserted, + return &ConnectionOptions_KubemqQueue{ + KubemqQueue: &asserted, }, true - case "gcppubsub": - asserted, ok := connArgs.(args.GCPPubSubConn) + case "awskinesis": + asserted, ok := connArgs.(args.AWSKinesisConn) if !ok { return nil, false } - return &ConnectionOptions_GcpPubsub{ - GcpPubsub: &asserted, + return &ConnectionOptions_AwsKinesis{ + AwsKinesis: &asserted, }, true case "activemq": asserted, ok := connArgs.(args.ActiveMQConn) @@ -98,50 +80,41 @@ func GenerateConnOpts(backend string, connArgs interface{}) (IsConnectionOptions return &ConnectionOptions_ActiveMq{ ActiveMq: &asserted, }, true - case "awssns": - asserted, ok := connArgs.(args.AWSSNSConn) - if !ok { - return nil, false - } - - return &ConnectionOptions_AwsSns{ - AwsSns: &asserted, - }, true - case "redispubsub": - asserted, ok := connArgs.(args.RedisPubSubConn) + case "nsq": + asserted, ok := connArgs.(args.NSQConn) if !ok { return nil, false } - return &ConnectionOptions_RedisPubsub{ - RedisPubsub: &asserted, + return &ConnectionOptions_Nsq{ + Nsq: &asserted, }, true - case "postgres": - asserted, ok := connArgs.(args.PostgresConn) + case "rabbit": + asserted, ok := connArgs.(args.RabbitConn) if !ok { return nil, false } - return &ConnectionOptions_Postgres{ - Postgres: &asserted, + return &ConnectionOptions_Rabbit{ + Rabbit: &asserted, }, true - case "rabbitstreams": - asserted, ok := connArgs.(args.RabbitStreamsConn) + case "redispubsub": + asserted, ok := connArgs.(args.RedisPubSubConn) if !ok { return nil, false } - return &ConnectionOptions_RabbitStreams{ - RabbitStreams: &asserted, + return &ConnectionOptions_RedisPubsub{ + RedisPubsub: &asserted, }, true - case "natsstreaming": - asserted, ok := connArgs.(args.NatsStreamingConn) + case "redisstreams": + asserted, ok := connArgs.(args.RedisStreamsConn) if !ok { return nil, false } - return &ConnectionOptions_NatsStreaming{ - NatsStreaming: &asserted, + return &ConnectionOptions_RedisStreams{ + RedisStreams: &asserted, }, true case "azureeventhub": asserted, ok := connArgs.(args.AzureEventHubConn) @@ -152,23 +125,23 @@ func GenerateConnOpts(backend string, connArgs interface{}) (IsConnectionOptions return &ConnectionOptions_AzureEventHub{ AzureEventHub: &asserted, }, true - case "kubemqqueue": - asserted, ok := connArgs.(args.KubeMQQueueConn) + case "awssqs": + asserted, ok := connArgs.(args.AWSSQSConn) if !ok { return nil, false } - return &ConnectionOptions_KubemqQueue{ - KubemqQueue: &asserted, + return &ConnectionOptions_AwsSqs{ + AwsSqs: &asserted, }, true - case "natsjetstream": - asserted, ok := connArgs.(args.NatsJetstreamConn) + case "mqtt": + asserted, ok := connArgs.(args.MQTTConn) if !ok { return nil, false } - return &ConnectionOptions_NatsJetstream{ - NatsJetstream: &asserted, + return &ConnectionOptions_Mqtt{ + Mqtt: &asserted, }, true case "kafka": asserted, ok := connArgs.(args.KafkaConn) @@ -179,6 +152,15 @@ func GenerateConnOpts(backend string, connArgs interface{}) (IsConnectionOptions return &ConnectionOptions_Kafka{ Kafka: &asserted, }, true + case "awssns": + asserted, ok := connArgs.(args.AWSSNSConn) + if !ok { + return nil, false + } + + return &ConnectionOptions_AwsSns{ + AwsSns: &asserted, + }, true case "mongo": asserted, ok := connArgs.(args.MongoConn) if !ok { @@ -188,6 +170,33 @@ func GenerateConnOpts(backend string, connArgs interface{}) (IsConnectionOptions return &ConnectionOptions_Mongo{ Mongo: &asserted, }, true + case "natsstreaming": + asserted, ok := connArgs.(args.NatsStreamingConn) + if !ok { + return nil, false + } + + return &ConnectionOptions_NatsStreaming{ + NatsStreaming: &asserted, + }, true + case "pulsar": + asserted, ok := connArgs.(args.PulsarConn) + if !ok { + return nil, false + } + + return &ConnectionOptions_Pulsar{ + Pulsar: &asserted, + }, true + case "rabbitstreams": + asserted, ok := connArgs.(args.RabbitStreamsConn) + if !ok { + return nil, false + } + + return &ConnectionOptions_RabbitStreams{ + RabbitStreams: &asserted, + }, true default: return nil, false } diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_connection.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_connection.pb.go index 7fc1e4b0..53c44230 100644 --- a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_connection.pb.go +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_connection.pb.go @@ -49,6 +49,7 @@ type ConnectionOptions struct { // *ConnectionOptions_KubemqQueue // *ConnectionOptions_GcpPubsub // *ConnectionOptions_NatsJetstream + // *ConnectionOptions_AwsKinesis Conn isConnectionOptions_Conn `protobuf_oneof:"conn"` // Used internally by plumber XId string `protobuf:"bytes,1000,opt,name=_id,json=Id,proto3" json:"_id,omitempty"` @@ -180,6 +181,10 @@ type ConnectionOptions_NatsJetstream struct { NatsJetstream *args.NatsJetstreamConn `protobuf:"bytes,119,opt,name=nats_jetstream,json=natsJetstream,proto3,oneof"` } +type ConnectionOptions_AwsKinesis struct { + AwsKinesis *args.AWSKinesisConn `protobuf:"bytes,120,opt,name=aws_kinesis,json=awsKinesis,proto3,oneof"` +} + func (*ConnectionOptions_Kafka) isConnectionOptions_Conn() {} func (*ConnectionOptions_ActiveMq) isConnectionOptions_Conn() {} @@ -220,6 +225,8 @@ func (*ConnectionOptions_GcpPubsub) isConnectionOptions_Conn() {} func (*ConnectionOptions_NatsJetstream) isConnectionOptions_Conn() {} +func (*ConnectionOptions_AwsKinesis) isConnectionOptions_Conn() {} + func (m *ConnectionOptions) GetConn() isConnectionOptions_Conn { if m != nil { return m.Conn @@ -367,6 +374,13 @@ func (m *ConnectionOptions) GetNatsJetstream() *args.NatsJetstreamConn { return nil } +func (m *ConnectionOptions) GetAwsKinesis() *args.AWSKinesisConn { + if x, ok := m.GetConn().(*ConnectionOptions_AwsKinesis); ok { + return x.AwsKinesis + } + return nil +} + func (m *ConnectionOptions) GetXId() string { if m != nil { return m.XId @@ -397,6 +411,7 @@ func (*ConnectionOptions) XXX_OneofWrappers() []interface{} { (*ConnectionOptions_KubemqQueue)(nil), (*ConnectionOptions_GcpPubsub)(nil), (*ConnectionOptions_NatsJetstream)(nil), + (*ConnectionOptions_AwsKinesis)(nil), } } @@ -407,52 +422,54 @@ func init() { func init() { proto.RegisterFile("opts/ps_opts_connection.proto", fileDescriptor_894e2be3fdae18cb) } var fileDescriptor_894e2be3fdae18cb = []byte{ - // 748 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x55, 0x4d, 0x4f, 0xdb, 0x4a, - 0x14, 0x7d, 0x7c, 0x05, 0x32, 0xbc, 0xbc, 0xf7, 0x18, 0xf1, 0x60, 0x48, 0x4b, 0x9b, 0xa2, 0x2e, - 0x90, 0xaa, 0xc6, 0x2a, 0x5d, 0xb4, 0x15, 0x2b, 0xa0, 0x15, 0xb4, 0x28, 0x34, 0xc1, 0x48, 0x95, - 0xba, 0xb1, 0x6c, 0x67, 0x70, 0x0c, 0xf1, 0xd8, 0x9e, 0x8f, 0x20, 0xf5, 0x17, 0xf7, 0x37, 0x74, - 0x55, 0xcd, 0x57, 0xc8, 0x34, 0x93, 0x0d, 0x26, 0xf7, 0x9c, 0x73, 0xe7, 0xde, 0xe3, 0x7b, 0xc7, - 0x60, 0xbf, 0xac, 0x38, 0x0b, 0x2a, 0x16, 0xc9, 0x67, 0x94, 0x96, 0x84, 0xe0, 0x94, 0xe7, 0x25, - 0xe9, 0x56, 0xb4, 0xe4, 0x25, 0xdc, 0x54, 0x0f, 0xd6, 0x95, 0x68, 0x1b, 0xc5, 0x34, 0x53, 0x5c, - 0xf9, 0x8c, 0xee, 0xe3, 0xdb, 0xfb, 0x58, 0xd3, 0xda, 0x4f, 0x1c, 0x24, 0x4e, 0x79, 0x3e, 0xc1, - 0x45, 0x6d, 0xc0, 0xb6, 0x0b, 0x3e, 0xb0, 0x88, 0x11, 0xb6, 0x18, 0xab, 0x2d, 0xe6, 0x1e, 0x57, - 0x94, 0x24, 0x2b, 0x0d, 0xb2, 0xeb, 0x20, 0x24, 0xe6, 0x56, 0xf2, 0x62, 0x0e, 0x88, 0x18, 0xa7, - 0x38, 0x2e, 0x72, 0x92, 0x2d, 0xa6, 0xdc, 0x61, 0xae, 0x59, 0x86, 0xb2, 0xe3, 0x52, 0x58, 0xed, - 0x3d, 0xb6, 0xa8, 0x39, 0x37, 0xc0, 0xbe, 0x03, 0x64, 0x69, 0x15, 0x55, 0x22, 0x61, 0x22, 0x31, - 0xf0, 0x73, 0xd7, 0x37, 0x91, 0xe0, 0xa2, 0x8e, 0x6a, 0x81, 0x05, 0xf6, 0xda, 0x57, 0x95, 0x8c, - 0x67, 0x14, 0xdb, 0x9e, 0xf6, 0x5c, 0x50, 0x8c, 0x59, 0x4c, 0xbd, 0x10, 0x8d, 0x93, 0x24, 0xe7, - 0xde, 0x36, 0x35, 0x64, 0xbc, 0x60, 0xde, 0xb2, 0x28, 0x1e, 0xe6, 0xcc, 0xad, 0xbb, 0xe3, 0x21, - 0xb8, 0x29, 0x5e, 0xba, 0xaf, 0xef, 0x87, 0xa0, 0x38, 0x62, 0x98, 0x4e, 0xf2, 0x14, 0x47, 0x89, - 0xb0, 0xac, 0x03, 0x0f, 0x0b, 0x4f, 0x30, 0xe1, 0xd1, 0xc8, 0x9e, 0x75, 0xf0, 0xab, 0x09, 0xb6, - 0xce, 0xa6, 0xd3, 0xf7, 0xb5, 0x92, 0x7f, 0x19, 0x84, 0x60, 0x95, 0xc4, 0x05, 0x46, 0x4b, 0x9d, - 0xa5, 0xc3, 0xe6, 0xb5, 0xfa, 0x1f, 0x6e, 0x83, 0x35, 0x52, 0x72, 0xcc, 0xd0, 0xb2, 0x0a, 0xea, - 0x1f, 0xb0, 0x0b, 0xd6, 0xd4, 0x40, 0xa2, 0x61, 0x67, 0xe9, 0x70, 0xf3, 0x68, 0xa7, 0x6b, 0x06, - 0x57, 0x1e, 0xd9, 0xbd, 0x94, 0x88, 0xcc, 0x7e, 0xf1, 0xd7, 0xb5, 0xa6, 0xc1, 0xf7, 0xa0, 0xa9, - 0xc7, 0x34, 0x2a, 0x6a, 0x84, 0x95, 0x66, 0xcf, 0xd1, 0x9c, 0x28, 0xb4, 0x37, 0x30, 0xb2, 0x0d, - 0xcd, 0xee, 0xd5, 0xf0, 0x08, 0xac, 0x9b, 0x39, 0x45, 0xb7, 0x4a, 0xb7, 0xeb, 0xea, 0xbe, 0x85, - 0xe1, 0x20, 0x34, 0xaa, 0x46, 0xfc, 0xc0, 0xc2, 0x9a, 0x4d, 0x35, 0x84, 0xa1, 0x6c, 0x81, 0xe6, - 0xca, 0xd1, 0x10, 0xd5, 0x91, 0x9a, 0x79, 0x34, 0xf2, 0x74, 0xd4, 0x93, 0x88, 0xed, 0x48, 0xd1, - 0xe0, 0x2b, 0xe9, 0x15, 0x67, 0x28, 0x57, 0xf4, 0xff, 0x1d, 0xfa, 0x55, 0xcc, 0x99, 0x61, 0x2b, - 0x12, 0x3c, 0x07, 0xff, 0xb8, 0xdb, 0x81, 0xee, 0x94, 0xec, 0xd9, 0x9c, 0x2c, 0xb4, 0x0c, 0xa3, - 0x6f, 0x91, 0xd9, 0x20, 0x3c, 0x04, 0x2b, 0x84, 0xd5, 0xe8, 0x5e, 0xa9, 0xb7, 0x5d, 0x75, 0x68, - 0xcd, 0x93, 0x14, 0xf8, 0x0e, 0x6c, 0xd8, 0xc9, 0x46, 0x63, 0x8f, 0xe1, 0x7d, 0x03, 0x5a, 0xc3, - 0x2d, 0x19, 0xbe, 0x01, 0x0d, 0x3d, 0xf5, 0xa8, 0xf0, 0x78, 0xd7, 0x57, 0x90, 0xf5, 0x4e, 0x13, - 0xa5, 0x44, 0x8f, 0x3c, 0x22, 0x1e, 0xc9, 0xb5, 0x82, 0xac, 0x44, 0x13, 0xa5, 0x23, 0xee, 0x96, - 0xa0, 0xd2, 0xe3, 0x88, 0x96, 0xea, 0xf6, 0x6d, 0xa5, 0x2d, 0x3a, 0x1b, 0x84, 0x27, 0xe0, 0xef, - 0xd9, 0x5d, 0x42, 0x95, 0x4a, 0xf3, 0xd4, 0x4d, 0x23, 0x09, 0x7d, 0x91, 0x84, 0x22, 0x31, 0x49, - 0x36, 0xa9, 0x09, 0x31, 0x91, 0xc0, 0x8f, 0xa0, 0xe5, 0x6c, 0x1b, 0xaa, 0x55, 0x8e, 0xfd, 0xf9, - 0x1c, 0x6e, 0x25, 0xfa, 0x60, 0x5b, 0xc8, 0x05, 0xf8, 0xf7, 0x8f, 0x5d, 0x43, 0xd4, 0xd3, 0xd2, - 0x89, 0xe4, 0x7c, 0x92, 0x94, 0x8b, 0x69, 0x35, 0xad, 0x78, 0x36, 0x08, 0xaf, 0xc0, 0xd6, 0xdc, - 0x6e, 0x23, 0xa6, 0x72, 0x75, 0xe6, 0x73, 0x85, 0x9a, 0x74, 0x2a, 0x6c, 0x59, 0xba, 0x8c, 0xc7, - 0xb0, 0x1c, 0x55, 0x79, 0x7b, 0x22, 0xee, 0x19, 0xd5, 0xde, 0xe0, 0xe6, 0xc6, 0x8e, 0xaa, 0x24, - 0x49, 0x3f, 0x67, 0xaf, 0x4c, 0x24, 0x3c, 0x7e, 0x5e, 0x8a, 0x04, 0xf7, 0x06, 0x03, 0x89, 0x5b, - 0x3f, 0xb5, 0x46, 0x85, 0xe0, 0x31, 0x00, 0x8f, 0x97, 0x32, 0x9a, 0xa8, 0x04, 0x6d, 0x27, 0xc1, - 0xf9, 0x59, 0xdf, 0x79, 0x1d, 0xcd, 0x2c, 0xad, 0xcc, 0xcb, 0xb0, 0xab, 0x32, 0xfd, 0x4a, 0xa0, - 0x87, 0x05, 0xab, 0xf2, 0xc5, 0x32, 0x66, 0x57, 0x65, 0x1a, 0x84, 0xff, 0x81, 0x95, 0x28, 0x1f, - 0xa2, 0x9f, 0xeb, 0xea, 0xde, 0x5a, 0xfe, 0x3c, 0x3c, 0x6d, 0x80, 0x55, 0xf9, 0xc5, 0x3d, 0x3d, - 0xfe, 0xfe, 0x21, 0xcb, 0xb9, 0xbc, 0x0c, 0xd3, 0xb2, 0x08, 0x92, 0x98, 0xa7, 0xa3, 0xb4, 0xa4, - 0x55, 0x50, 0x8d, 0x45, 0x91, 0x60, 0xfa, 0x9a, 0xa5, 0x23, 0x5c, 0xc4, 0x2c, 0x48, 0x44, 0x3e, - 0x1e, 0x06, 0x59, 0x19, 0xe8, 0x93, 0x03, 0xf9, 0x55, 0x4e, 0x1a, 0xea, 0xc7, 0xdb, 0xdf, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x55, 0x7d, 0xeb, 0x2c, 0xca, 0x07, 0x00, 0x00, + // 782 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0x5d, 0x4f, 0x1b, 0x39, + 0x14, 0x5d, 0xbe, 0x02, 0x38, 0x9b, 0xdd, 0xc5, 0x62, 0xc1, 0x84, 0x85, 0xcd, 0xa2, 0x7d, 0x40, + 0x5a, 0x6d, 0xa2, 0x65, 0x1f, 0xda, 0x0a, 0xa9, 0x12, 0xd0, 0x0a, 0x5a, 0x14, 0x9a, 0x30, 0x48, + 0x95, 0xfa, 0x32, 0xf2, 0x4c, 0xcc, 0x64, 0x48, 0xc6, 0xf3, 0x61, 0x3b, 0xa9, 0xfa, 0xd3, 0xfa, + 0x8b, 0xfa, 0x33, 0x2a, 0x7f, 0x85, 0x98, 0x98, 0xbe, 0x64, 0x32, 0xf7, 0x9c, 0x73, 0x7d, 0x7d, + 0xe6, 0x5e, 0x1b, 0x1c, 0xe4, 0x05, 0x67, 0x9d, 0x82, 0x85, 0xf2, 0x19, 0xc6, 0x39, 0xa5, 0x24, + 0xe6, 0x69, 0x4e, 0xdb, 0x45, 0x95, 0xf3, 0x1c, 0xd6, 0xd5, 0x83, 0xb5, 0x25, 0xda, 0x44, 0xb8, + 0x4a, 0x14, 0x57, 0x3e, 0xc3, 0x11, 0xbe, 0x1f, 0x61, 0x4d, 0x6b, 0xee, 0x3b, 0x08, 0x8e, 0x79, + 0x3a, 0x21, 0x59, 0x69, 0xc0, 0x43, 0x17, 0x9c, 0xb2, 0x70, 0x94, 0x52, 0xc2, 0x52, 0x66, 0xf0, + 0xe6, 0x02, 0xce, 0xe8, 0x0f, 0xb0, 0xd2, 0x62, 0x6e, 0x39, 0x59, 0x4e, 0x93, 0xdc, 0x20, 0xbb, + 0x0e, 0x42, 0x31, 0xb7, 0x92, 0xbf, 0x16, 0x80, 0x90, 0xf1, 0x8a, 0xe0, 0x2c, 0xa5, 0xc9, 0xf3, + 0x94, 0x07, 0xc2, 0x35, 0xcb, 0x50, 0x76, 0x5c, 0x0a, 0x2b, 0xbd, 0xcb, 0x66, 0x25, 0xe7, 0x06, + 0x38, 0x70, 0x80, 0x24, 0x2e, 0xc2, 0x42, 0x44, 0x4c, 0x44, 0x06, 0xfe, 0xd3, 0xf5, 0x55, 0x44, + 0x24, 0x2b, 0xc3, 0x52, 0x10, 0x41, 0xbc, 0xf6, 0x16, 0x39, 0xe3, 0x49, 0x45, 0xec, 0x9e, 0xf6, + 0x5c, 0x50, 0x8c, 0x19, 0xae, 0xbc, 0x50, 0x85, 0xa3, 0x28, 0xe5, 0xde, 0x6d, 0x6a, 0xc8, 0x78, + 0xc1, 0xbc, 0x65, 0x55, 0x64, 0x90, 0x32, 0xb7, 0xee, 0x96, 0x87, 0xe0, 0xa6, 0xf8, 0xdb, 0xfd, + 0x7c, 0x5f, 0x44, 0x45, 0x42, 0x46, 0xaa, 0x49, 0x1a, 0x93, 0x30, 0x12, 0x96, 0x75, 0xe4, 0x61, + 0x91, 0x09, 0xa1, 0x3c, 0x1c, 0xda, 0xb5, 0x8e, 0xbe, 0x02, 0xb0, 0x75, 0x31, 0xeb, 0xce, 0x0f, + 0x85, 0xfc, 0x65, 0x10, 0x82, 0x55, 0x8a, 0x33, 0x82, 0x96, 0x5a, 0x4b, 0xc7, 0x9b, 0xb7, 0xea, + 0x3f, 0xdc, 0x06, 0x6b, 0x34, 0xe7, 0x84, 0xa1, 0x65, 0x15, 0xd4, 0x2f, 0xb0, 0x0d, 0xd6, 0x54, + 0xc3, 0xa2, 0x41, 0x6b, 0xe9, 0xb8, 0x7e, 0xb2, 0xd3, 0x36, 0x8d, 0x2d, 0x97, 0x6c, 0x5f, 0x4b, + 0x44, 0x66, 0xbf, 0xfa, 0xe9, 0x56, 0xd3, 0xe0, 0x4b, 0xb0, 0xa9, 0xdb, 0x38, 0xcc, 0x4a, 0x44, + 0x94, 0x66, 0xcf, 0xd1, 0x9c, 0x29, 0xb4, 0xdb, 0x37, 0xb2, 0x0d, 0xcd, 0xee, 0x96, 0xf0, 0x04, + 0xac, 0x9b, 0x3e, 0x45, 0xf7, 0x4a, 0xb7, 0xeb, 0xea, 0x3e, 0x06, 0x41, 0x3f, 0x30, 0xaa, 0x1a, + 0x9e, 0xb2, 0xa0, 0x64, 0x33, 0x0d, 0x65, 0x28, 0x79, 0x46, 0x73, 0xe3, 0x68, 0xa8, 0xda, 0x91, + 0xea, 0x79, 0x34, 0xf4, 0xec, 0xa8, 0x2b, 0x11, 0xbb, 0x23, 0x45, 0x83, 0xff, 0x48, 0xaf, 0x38, + 0x43, 0xa9, 0xa2, 0xff, 0xee, 0xd0, 0x6f, 0x30, 0x67, 0x86, 0xad, 0x48, 0xf0, 0x12, 0xfc, 0xe2, + 0x4e, 0x07, 0x7a, 0x50, 0xb2, 0xc3, 0x05, 0x59, 0x60, 0x19, 0x46, 0xdf, 0xa0, 0xf3, 0x41, 0x78, + 0x0c, 0x56, 0x28, 0x2b, 0xd1, 0x48, 0xa9, 0xb7, 0x5d, 0x75, 0x60, 0xcd, 0x93, 0x14, 0xf8, 0x02, + 0x6c, 0xd8, 0xce, 0x46, 0x63, 0x8f, 0xe1, 0x3d, 0x03, 0x5a, 0xc3, 0x2d, 0x19, 0xfe, 0x07, 0x6a, + 0xba, 0xeb, 0x51, 0xe6, 0xf1, 0xae, 0xa7, 0x20, 0xeb, 0x9d, 0x26, 0x4a, 0x89, 0x6e, 0x79, 0x44, + 0x3d, 0x92, 0x5b, 0x05, 0x59, 0x89, 0x26, 0x4a, 0x47, 0xdc, 0x29, 0x41, 0xb9, 0xc7, 0x11, 0x2d, + 0xd5, 0xdb, 0xb7, 0x95, 0x36, 0xaa, 0xf9, 0x20, 0x3c, 0x03, 0x3f, 0xcf, 0xcf, 0x12, 0x2a, 0x54, + 0x9a, 0x3f, 0xdc, 0x34, 0x92, 0xd0, 0x13, 0x51, 0x20, 0x22, 0x93, 0xa4, 0x5e, 0x99, 0x10, 0x13, + 0x11, 0x7c, 0x03, 0x1a, 0xce, 0xb4, 0xa1, 0x52, 0xe5, 0x38, 0x58, 0xcc, 0xe1, 0x56, 0xa2, 0x17, + 0xb6, 0x85, 0x5c, 0x81, 0x5f, 0x9f, 0xcc, 0x1a, 0xaa, 0x3c, 0x5b, 0x3a, 0x93, 0x9c, 0xb7, 0x92, + 0x72, 0x35, 0xab, 0xa6, 0x81, 0xe7, 0x83, 0xf0, 0x06, 0x6c, 0x2d, 0xcc, 0x36, 0x62, 0x2a, 0x57, + 0x6b, 0x31, 0x57, 0xa0, 0x49, 0xe7, 0xc2, 0x96, 0xa5, 0xcb, 0x78, 0x0c, 0xcb, 0x56, 0x95, 0xa7, + 0x27, 0xe2, 0x9e, 0x56, 0xed, 0xf6, 0xef, 0xee, 0x6c, 0xab, 0x4a, 0x92, 0xf4, 0x73, 0xfe, 0xc8, + 0x44, 0xc2, 0xe3, 0xe7, 0xb5, 0x88, 0x48, 0xb7, 0xdf, 0x97, 0xb8, 0xf5, 0x53, 0x6b, 0x54, 0x08, + 0x9e, 0x02, 0xf0, 0x78, 0x28, 0xa3, 0x89, 0x4a, 0xd0, 0x74, 0x12, 0x5c, 0x5e, 0xf4, 0x9c, 0xcf, + 0xb1, 0x99, 0xc4, 0x85, 0xf9, 0x18, 0x76, 0x54, 0x66, 0xb7, 0x04, 0x9a, 0x3e, 0x33, 0x2a, 0xef, + 0x2d, 0x63, 0x7e, 0x54, 0x66, 0x41, 0xf8, 0x1a, 0xd4, 0xe7, 0x2e, 0x47, 0xf4, 0x59, 0x65, 0xd9, + 0x7f, 0x7a, 0x10, 0x5c, 0x6b, 0xd8, 0xa4, 0x00, 0x78, 0xca, 0x4c, 0x04, 0xfe, 0x06, 0x56, 0xc2, + 0x74, 0x80, 0xbe, 0xad, 0xab, 0x73, 0x6f, 0xf9, 0xdd, 0xe0, 0xbc, 0x06, 0x56, 0xe5, 0x8d, 0x7e, + 0x7e, 0xfa, 0xe9, 0x55, 0x92, 0x72, 0x79, 0x98, 0xc6, 0x79, 0xd6, 0x89, 0x30, 0x8f, 0x87, 0x71, + 0x5e, 0x15, 0x9d, 0x62, 0x2c, 0xb2, 0x88, 0x54, 0xff, 0xb2, 0x78, 0x48, 0x32, 0xcc, 0x3a, 0x91, + 0x48, 0xc7, 0x83, 0x4e, 0x92, 0x77, 0xf4, 0x9a, 0x1d, 0x79, 0xeb, 0x47, 0x35, 0xf5, 0xf2, 0xff, + 0xf7, 0x00, 0x00, 0x00, 0xff, 0xff, 0x61, 0x03, 0x63, 0xca, 0x2a, 0x08, 0x00, 0x00, } diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_dynamic.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_dynamic.pb.go index 64c61a98..7b8f0501 100644 --- a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_dynamic.pb.go +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_dynamic.pb.go @@ -65,10 +65,12 @@ type DynamicOptions struct { // @gotags: kong:"cmd,help='RabbitMQ Streams'" RabbitStreams *DynamicGroupRabbitStreamsOptions `protobuf:"bytes,116,opt,name=rabbit_streams,json=rabbitStreams,proto3" json:"rabbit_streams,omitempty" kong:"cmd,help='RabbitMQ Streams'"` // @gotags: kong:"cmd,help='NATS JetStream'" - NatsJetstream *DynamicGroupNatsJetstreamOptions `protobuf:"bytes,117,opt,name=nats_jetstream,json=natsJetstream,proto3" json:"nats_jetstream,omitempty" kong:"cmd,help='NATS JetStream'"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + NatsJetstream *DynamicGroupNatsJetstreamOptions `protobuf:"bytes,117,opt,name=nats_jetstream,json=natsJetstream,proto3" json:"nats_jetstream,omitempty" kong:"cmd,help='NATS JetStream'"` + // @gotags: kong:"cmd,help='AWS Kinesis Streams'" + AwsKinesis *DynamicGroupAWSKinesisOptions `protobuf:"bytes,118,opt,name=aws_kinesis,json=awsKinesis,proto3" json:"aws_kinesis,omitempty" kong:"cmd,help='AWS Kinesis Streams'"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *DynamicOptions) Reset() { *m = DynamicOptions{} } @@ -250,6 +252,13 @@ func (m *DynamicOptions) GetNatsJetstream() *DynamicGroupNatsJetstreamOptions { return nil } +func (m *DynamicOptions) GetAwsKinesis() *DynamicGroupAWSKinesisOptions { + if m != nil { + return m.AwsKinesis + } + return nil +} + type DynamicGroupKafkaOptions struct { // @gotags: kong:"embed" XConn *args.KafkaConn `protobuf:"bytes,1,opt,name=_conn,json=Conn,proto3" json:"_conn,omitempty" kong:"embed"` @@ -1132,6 +1141,55 @@ func (m *DynamicGroupPulsarOptions) GetArgs() *args.PulsarWriteArgs { return nil } +type DynamicGroupAWSKinesisOptions struct { + // @gotags: kong:"embed" + XConn *args.AWSKinesisConn `protobuf:"bytes,1,opt,name=_conn,json=Conn,proto3" json:"_conn,omitempty" kong:"embed"` + // @gotags: kong:"embed" + Args *args.AWSKinesisWriteArgs `protobuf:"bytes,2,opt,name=args,proto3" json:"args,omitempty" kong:"embed"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DynamicGroupAWSKinesisOptions) Reset() { *m = DynamicGroupAWSKinesisOptions{} } +func (m *DynamicGroupAWSKinesisOptions) String() string { return proto.CompactTextString(m) } +func (*DynamicGroupAWSKinesisOptions) ProtoMessage() {} +func (*DynamicGroupAWSKinesisOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_11709e700f0eb834, []int{19} +} + +func (m *DynamicGroupAWSKinesisOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DynamicGroupAWSKinesisOptions.Unmarshal(m, b) +} +func (m *DynamicGroupAWSKinesisOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DynamicGroupAWSKinesisOptions.Marshal(b, m, deterministic) +} +func (m *DynamicGroupAWSKinesisOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_DynamicGroupAWSKinesisOptions.Merge(m, src) +} +func (m *DynamicGroupAWSKinesisOptions) XXX_Size() int { + return xxx_messageInfo_DynamicGroupAWSKinesisOptions.Size(m) +} +func (m *DynamicGroupAWSKinesisOptions) XXX_DiscardUnknown() { + xxx_messageInfo_DynamicGroupAWSKinesisOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_DynamicGroupAWSKinesisOptions proto.InternalMessageInfo + +func (m *DynamicGroupAWSKinesisOptions) GetXConn() *args.AWSKinesisConn { + if m != nil { + return m.XConn + } + return nil +} + +func (m *DynamicGroupAWSKinesisOptions) GetArgs() *args.AWSKinesisWriteArgs { + if m != nil { + return m.Args + } + return nil +} + func init() { proto.RegisterType((*DynamicOptions)(nil), "protos.opts.DynamicOptions") proto.RegisterType((*DynamicGroupKafkaOptions)(nil), "protos.opts.DynamicGroupKafkaOptions") @@ -1152,83 +1210,87 @@ func init() { proto.RegisterType((*DynamicGroupGCPPubSubOptions)(nil), "protos.opts.DynamicGroupGCPPubSubOptions") proto.RegisterType((*DynamicGroupKubeMQQueueOptions)(nil), "protos.opts.DynamicGroupKubeMQQueueOptions") proto.RegisterType((*DynamicGroupPulsarOptions)(nil), "protos.opts.DynamicGroupPulsarOptions") + proto.RegisterType((*DynamicGroupAWSKinesisOptions)(nil), "protos.opts.DynamicGroupAWSKinesisOptions") } func init() { proto.RegisterFile("opts/ps_opts_dynamic.proto", fileDescriptor_11709e700f0eb834) } var fileDescriptor_11709e700f0eb834 = []byte{ - // 1157 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x5d, 0x6f, 0xdb, 0x36, - 0x14, 0x85, 0xd6, 0xb4, 0x4b, 0xe8, 0x26, 0xc5, 0x88, 0x35, 0x61, 0x92, 0x36, 0x71, 0xdd, 0x74, - 0x48, 0xd7, 0xc6, 0x5e, 0x13, 0x64, 0x5b, 0x51, 0x60, 0x43, 0xda, 0x0e, 0xe9, 0x36, 0xc4, 0x8b, - 0xed, 0x0c, 0x05, 0xb6, 0x07, 0x41, 0x92, 0x59, 0x5b, 0x4d, 0x2c, 0xc9, 0xa4, 0x98, 0xee, 0xe3, - 0x69, 0xc0, 0x9e, 0x06, 0x0c, 0xd8, 0xd3, 0xfe, 0xd5, 0xfe, 0xd3, 0x40, 0x52, 0x52, 0x74, 0xf5, - 0xdd, 0x97, 0x18, 0xe1, 0x3d, 0xe7, 0xdc, 0xa3, 0xcb, 0xcb, 0x4b, 0xa2, 0x0d, 0x3f, 0x08, 0x79, - 0x2f, 0xe0, 0xa6, 0xfc, 0x35, 0xc7, 0xbf, 0x7a, 0xd6, 0xcc, 0x75, 0xba, 0x01, 0xf3, 0x43, 0x1f, - 0xb7, 0xd4, 0x0f, 0xef, 0xca, 0xd0, 0xc6, 0xa6, 0xc5, 0x26, 0x0a, 0x28, 0x7f, 0x4d, 0xcb, 0x09, - 0xdd, 0x4b, 0x3a, 0x9b, 0x6b, 0xe4, 0xc6, 0x0e, 0x0c, 0xfe, 0x26, 0x18, 0x35, 0x39, 0x65, 0x97, - 0xae, 0x43, 0x4d, 0x5b, 0xf0, 0x08, 0xd5, 0x29, 0x40, 0xd1, 0x4b, 0xea, 0x85, 0xe6, 0x54, 0xd8, - 0x11, 0x66, 0x03, 0x62, 0xde, 0x71, 0x93, 0xcf, 0x79, 0x79, 0xcc, 0x8b, 0x63, 0x77, 0x41, 0x6c, - 0xe2, 0x04, 0x66, 0x20, 0x6c, 0x9e, 0xc8, 0x12, 0x10, 0x3e, 0xb7, 0xde, 0x9c, 0x5b, 0x51, 0x64, - 0x1b, 0x46, 0x84, 0x4d, 0x67, 0x73, 0x73, 0x2e, 0xa8, 0xa0, 0x11, 0x60, 0x0d, 0x00, 0x66, 0xf3, - 0x30, 0x2c, 0x0c, 0x78, 0x56, 0x18, 0x7b, 0xb9, 0x97, 0x0b, 0x98, 0x6f, 0x69, 0xc8, 0x43, 0x46, - 0xad, 0x59, 0x39, 0x44, 0xc7, 0x5d, 0x6f, 0x12, 0x41, 0x56, 0x21, 0x84, 0xc7, 0xb5, 0x5e, 0x07, - 0xeb, 0x81, 0xb8, 0xe0, 0x16, 0x2b, 0x0c, 0x31, 0xcb, 0xb6, 0xdd, 0xb0, 0x30, 0xa1, 0x0e, 0x45, - 0x29, 0x79, 0x61, 0x25, 0x18, 0x1d, 0xbb, 0x1c, 0x16, 0xb1, 0x5d, 0x00, 0x00, 0x12, 0x9d, 0xff, - 0x5a, 0x68, 0xe5, 0xa5, 0xee, 0xa1, 0x1f, 0x82, 0xd0, 0xf5, 0x3d, 0x8e, 0x37, 0xd1, 0x92, 0x15, - 0xb8, 0x66, 0xe8, 0x9f, 0x53, 0x8f, 0x18, 0x6d, 0x63, 0x77, 0x69, 0xb8, 0x68, 0x05, 0xee, 0x99, - 0xfc, 0x1f, 0x77, 0xd0, 0xb2, 0x39, 0x61, 0x81, 0x63, 0x5a, 0xe3, 0x31, 0xa3, 0x9c, 0x93, 0x0f, - 0x14, 0xa0, 0x75, 0xcc, 0x02, 0xe7, 0x48, 0x2f, 0xe1, 0x27, 0xe8, 0xb6, 0xc6, 0x84, 0xee, 0x8c, - 0xfa, 0x22, 0x34, 0x39, 0x75, 0x7c, 0x6f, 0xcc, 0xc9, 0xb5, 0xb6, 0xb1, 0xbb, 0x3c, 0xc4, 0x12, - 0x7b, 0xa6, 0x43, 0x23, 0x1d, 0xc1, 0x3b, 0x68, 0x45, 0x53, 0x5c, 0x8f, 0x53, 0x47, 0x30, 0x4a, - 0x16, 0xda, 0xc6, 0xee, 0xe2, 0xf0, 0xa6, 0xc4, 0x7e, 0x1b, 0xad, 0xe1, 0x67, 0xe8, 0xba, 0x6a, - 0x04, 0x32, 0x6e, 0x1b, 0xbb, 0xad, 0xfd, 0x07, 0xdd, 0x54, 0xbb, 0x77, 0xa3, 0xaf, 0x38, 0x66, - 0xbe, 0x08, 0xbe, 0x97, 0xa8, 0xe8, 0x7b, 0x86, 0x9a, 0x83, 0x5f, 0xa2, 0xc5, 0xf8, 0x0c, 0x10, - 0xaa, 0xf8, 0xbb, 0xa5, 0xfc, 0x23, 0x05, 0x3c, 0x19, 0xc4, 0x12, 0x09, 0x13, 0x7f, 0x8d, 0x3e, - 0x8c, 0x5a, 0x9c, 0xbc, 0x51, 0x22, 0x9f, 0x94, 0x8b, 0xbc, 0x1e, 0x8d, 0x06, 0xa3, 0x58, 0xe2, - 0x86, 0xf5, 0x8e, 0x8f, 0xe6, 0x3c, 0x11, 0xf0, 0x38, 0x99, 0x34, 0x10, 0xe8, 0x43, 0x01, 0x8f, - 0xe3, 0x2f, 0xd1, 0x82, 0xec, 0x3e, 0x32, 0x55, 0xec, 0x9d, 0x52, 0x76, 0xdf, 0x0a, 0x79, 0xcc, - 0x55, 0x0c, 0x7c, 0x86, 0x56, 0x60, 0xdf, 0x12, 0x57, 0x69, 0xec, 0x55, 0x6a, 0x8c, 0x62, 0x74, - 0x2c, 0xb6, 0xec, 0xa5, 0x57, 0xf1, 0x21, 0xba, 0xe6, 0xf1, 0x39, 0x79, 0xab, 0xa4, 0xee, 0x97, - 0x4b, 0x8d, 0x92, 0x6a, 0x4a, 0x3c, 0xfe, 0x0a, 0xdd, 0xd0, 0x3d, 0x4d, 0xce, 0x6b, 0xca, 0x30, - 0x54, 0xb0, 0xa4, 0x0c, 0x9a, 0x25, 0xcb, 0x20, 0x4f, 0x36, 0xb9, 0xa8, 0x29, 0xc3, 0xc9, 0xe0, - 0xec, 0x2c, 0x29, 0x83, 0x64, 0xe0, 0x9f, 0xd1, 0x47, 0xb9, 0x79, 0x47, 0x66, 0x4a, 0xa6, 0x57, - 0xbe, 0x17, 0x92, 0x31, 0xd2, 0x84, 0xe7, 0x22, 0x29, 0xec, 0x2d, 0x0b, 0xae, 0xe3, 0x1f, 0xd1, - 0xad, 0xcc, 0x98, 0x24, 0x5e, 0x4d, 0x91, 0x95, 0xf4, 0x37, 0x12, 0xfe, 0x4a, 0xd8, 0x49, 0x91, - 0xad, 0xf4, 0x2a, 0x7e, 0x85, 0xd0, 0xd5, 0x84, 0x24, 0xbe, 0x52, 0x7c, 0x58, 0xaa, 0x78, 0xfc, - 0xe2, 0xf4, 0x54, 0xd8, 0xa3, 0x2b, 0xb5, 0xa5, 0x89, 0x13, 0x9c, 0x2a, 0x2e, 0xee, 0xa3, 0x9b, - 0xe9, 0x91, 0x49, 0x02, 0xa5, 0xf5, 0xa8, 0xfc, 0x28, 0x09, 0x9b, 0x9e, 0x0c, 0x06, 0x12, 0x1b, - 0xab, 0xb5, 0xb4, 0x80, 0x5a, 0x93, 0x7a, 0xe9, 0xc1, 0x43, 0xe6, 0x35, 0x7a, 0x43, 0x09, 0x86, - 0xee, 0x5a, 0x2c, 0x5a, 0x93, 0xfe, 0x06, 0x68, 0x19, 0xcc, 0x29, 0xc2, 0x94, 0xe0, 0xe3, 0x6a, - 0x41, 0xdd, 0x8e, 0xc9, 0xb6, 0x68, 0x4b, 0xd1, 0xa2, 0x6c, 0x35, 0x3d, 0x74, 0x09, 0xaf, 0x69, - 0xb5, 0x53, 0x05, 0x4b, 0x5a, 0x4d, 0xb3, 0xe4, 0xb9, 0x81, 0xe3, 0x97, 0x84, 0x35, 0x5b, 0xaa, - 0x5b, 0x36, 0x63, 0x6a, 0x99, 0xa5, 0x57, 0x93, 0xd3, 0x98, 0x5c, 0x34, 0x44, 0x34, 0x38, 0x8d, - 0xdf, 0xc5, 0x68, 0x70, 0x1a, 0x93, 0xd5, 0xce, 0x2f, 0x88, 0x94, 0x0d, 0x42, 0xfc, 0x08, 0x5d, - 0x37, 0x1d, 0xdf, 0xd3, 0x43, 0xbd, 0xb5, 0xbf, 0x1a, 0x27, 0x92, 0x97, 0x43, 0x57, 0x21, 0x5f, - 0xf8, 0x9e, 0x37, 0x5c, 0x90, 0x7f, 0x71, 0x0f, 0x2d, 0xc8, 0x75, 0x35, 0xdf, 0x5b, 0xfb, 0x9b, - 0x79, 0xec, 0x6b, 0xe6, 0x86, 0xf4, 0x88, 0x4d, 0xf8, 0x50, 0x01, 0x3b, 0x7f, 0x18, 0x68, 0xb3, - 0x62, 0x86, 0xe2, 0x2e, 0xcc, 0xbe, 0x0e, 0x14, 0x63, 0x70, 0xca, 0xc0, 0x3e, 0x30, 0xb0, 0x55, - 0x08, 0xcf, 0x7a, 0xf8, 0x1d, 0xad, 0x97, 0x4e, 0x60, 0xfc, 0x18, 0x1a, 0x58, 0x83, 0x8a, 0x0a, - 0x9a, 0x4a, 0xff, 0x19, 0x48, 0x7f, 0xa7, 0x00, 0xdc, 0x20, 0x79, 0xbf, 0x79, 0xf2, 0xfe, 0xfb, - 0x24, 0xef, 0xe7, 0x92, 0x0b, 0xb4, 0x56, 0x32, 0xfc, 0xf1, 0xa7, 0x30, 0xf5, 0x6d, 0xa0, 0x26, - 0x81, 0xa9, 0xc4, 0x5d, 0x90, 0x78, 0x23, 0x07, 0xcd, 0xa6, 0xfd, 0xc7, 0x40, 0xed, 0xba, 0x16, - 0xc5, 0x07, 0xd0, 0xc0, 0x56, 0x4e, 0x35, 0x61, 0xa4, 0x9c, 0x7c, 0x01, 0x9c, 0xdc, 0x2f, 0xe7, - 0x34, 0xb1, 0x94, 0xbd, 0xc3, 0xea, 0x2d, 0x25, 0x8c, 0xf7, 0xb0, 0x94, 0x70, 0xb2, 0x96, 0x18, - 0x5a, 0x2d, 0xbe, 0x0a, 0xf1, 0x43, 0xe8, 0xe3, 0x63, 0xa8, 0x39, 0x4a, 0x9f, 0x87, 0x3d, 0x90, - 0x7d, 0x3d, 0x8b, 0xac, 0xe9, 0x46, 0x70, 0x89, 0x56, 0x77, 0xa3, 0x86, 0x36, 0xec, 0x46, 0x0d, - 0xae, 0xdb, 0x83, 0xa2, 0x79, 0x58, 0xbd, 0x07, 0x80, 0xd1, 0x70, 0x0f, 0x00, 0x27, 0x6b, 0xe9, - 0x2f, 0x03, 0x6d, 0x55, 0xdf, 0x43, 0xf8, 0x09, 0x34, 0x94, 0xf9, 0xd0, 0x2b, 0x7c, 0xca, 0xce, - 0x21, 0xb0, 0x73, 0xaf, 0x8c, 0x91, 0x35, 0xf3, 0xb7, 0x81, 0xb6, 0x6b, 0xee, 0x30, 0xbc, 0x0f, - 0xdd, 0xdc, 0xcd, 0x6b, 0xe7, 0xab, 0xf3, 0x39, 0xb0, 0xd3, 0x29, 0xa5, 0xd4, 0xed, 0x57, 0xd1, - 0x93, 0xa4, 0x7a, 0xbf, 0x00, 0xa3, 0xe1, 0x7e, 0x01, 0x4e, 0xd6, 0xd2, 0xbf, 0x06, 0xea, 0xd4, - 0x3f, 0xc0, 0xf0, 0x21, 0x34, 0xd5, 0xce, 0x27, 0xb8, 0xe2, 0xa4, 0x6c, 0x3d, 0x05, 0xb6, 0x1e, - 0x54, 0xb1, 0x6a, 0x26, 0x6d, 0xea, 0x7d, 0x59, 0x3d, 0x69, 0x25, 0xb0, 0xe1, 0xa4, 0x95, 0xd0, - 0x6c, 0xda, 0x3f, 0x0d, 0x74, 0xa7, 0xea, 0x8d, 0x87, 0x7b, 0x30, 0x39, 0x54, 0x4c, 0xd0, 0x29, - 0x07, 0x07, 0xc0, 0xc1, 0x76, 0x31, 0xbe, 0xee, 0x18, 0xe5, 0x9f, 0x87, 0xd5, 0xc7, 0x28, 0x85, - 0x6f, 0x78, 0x8c, 0x52, 0x8c, 0x9a, 0x19, 0x07, 0x5e, 0x6f, 0xd5, 0x33, 0x4e, 0x43, 0x1b, 0xce, - 0x38, 0x0d, 0xce, 0x24, 0x7f, 0xfe, 0xec, 0xa7, 0xa7, 0x13, 0x37, 0x9c, 0x0a, 0xbb, 0xeb, 0xf8, - 0xb3, 0x9e, 0x6d, 0x85, 0xce, 0xd4, 0xf1, 0x59, 0xd0, 0x0b, 0x2e, 0xc4, 0xcc, 0xa6, 0x6c, 0x8f, - 0x3b, 0x53, 0x3a, 0xb3, 0x78, 0xcf, 0x16, 0xee, 0xc5, 0xb8, 0x37, 0xf1, 0x7b, 0x5a, 0xb2, 0x27, - 0x9f, 0x75, 0xf6, 0x0d, 0xf5, 0xcf, 0xc1, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x92, 0xf4, 0x90, - 0x1a, 0xcd, 0x11, 0x00, 0x00, + // 1213 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x5d, 0x4f, 0xdc, 0x46, + 0x14, 0x95, 0x1b, 0x42, 0x61, 0x16, 0x88, 0x3a, 0x6a, 0x60, 0x80, 0x00, 0x9b, 0x0d, 0xa9, 0xc8, + 0x07, 0xbb, 0x09, 0x94, 0xb6, 0x51, 0xa4, 0x56, 0x24, 0xa9, 0x48, 0x8b, 0xd8, 0xb2, 0xbb, 0x54, + 0x91, 0xda, 0x07, 0xcb, 0xf6, 0x4e, 0x16, 0x67, 0x59, 0xdb, 0x3b, 0x63, 0x43, 0x3f, 0x9e, 0x2a, + 0x55, 0xaa, 0x54, 0xa9, 0x52, 0x9f, 0xfa, 0xd0, 0x5f, 0x1b, 0xcd, 0x8c, 0x6d, 0x7c, 0xfd, 0x9d, + 0x17, 0x56, 0xdc, 0x7b, 0xce, 0xb9, 0xc7, 0x33, 0x77, 0xee, 0x0c, 0x5a, 0x73, 0x3d, 0x9f, 0x77, + 0x3c, 0xae, 0x8b, 0x5f, 0x7d, 0xf8, 0xab, 0x63, 0x4c, 0x6c, 0xab, 0xed, 0x31, 0xd7, 0x77, 0x71, + 0x43, 0xfe, 0xf0, 0xb6, 0x48, 0xad, 0xad, 0x1b, 0x6c, 0x24, 0x81, 0xe2, 0x57, 0x37, 0x2c, 0xdf, + 0xbe, 0xa4, 0x93, 0xa9, 0x42, 0xae, 0x6d, 0xc3, 0xe4, 0x6f, 0x01, 0xa3, 0x3a, 0xa7, 0xec, 0xd2, + 0xb6, 0xa8, 0x6e, 0x06, 0x3c, 0x44, 0xb5, 0x72, 0x50, 0xf4, 0x92, 0x3a, 0xbe, 0x7e, 0x1e, 0x98, + 0x21, 0x66, 0x13, 0x62, 0xae, 0xb8, 0x3e, 0xb6, 0x1d, 0xca, 0xed, 0x48, 0x63, 0x2d, 0x93, 0xe7, + 0xd3, 0x92, 0x9c, 0x13, 0xe5, 0x36, 0x40, 0x6e, 0x64, 0x79, 0xba, 0x17, 0x98, 0x3c, 0x2e, 0x4b, + 0x40, 0x7a, 0x6c, 0xbc, 0x1d, 0x1b, 0x61, 0x66, 0x0b, 0x66, 0x02, 0x93, 0x4e, 0xa6, 0xfa, 0x34, + 0xa0, 0x01, 0x0d, 0x01, 0x2b, 0x00, 0x30, 0x99, 0xfa, 0x7e, 0x6e, 0xc2, 0x31, 0xfc, 0xc8, 0xcb, + 0xdd, 0x4c, 0x42, 0x7f, 0x47, 0x7d, 0xee, 0x33, 0x6a, 0x4c, 0x8a, 0x21, 0x2a, 0x6f, 0x3b, 0xa3, + 0x10, 0xb2, 0x0c, 0x21, 0x3c, 0xda, 0x8b, 0x55, 0x10, 0xf7, 0x82, 0x0b, 0x6e, 0xb0, 0xdc, 0x14, + 0x33, 0x4c, 0xd3, 0xf6, 0x73, 0x0b, 0xaa, 0x54, 0x58, 0x92, 0xe7, 0xae, 0x04, 0xa3, 0x43, 0x9b, + 0xc3, 0x45, 0x6c, 0xe6, 0x00, 0x80, 0x44, 0xeb, 0xff, 0x05, 0xb4, 0xf4, 0x4a, 0xf5, 0xd8, 0x0f, + 0x9e, 0x6f, 0xbb, 0x0e, 0xc7, 0xeb, 0x68, 0xde, 0xf0, 0x6c, 0xdd, 0x77, 0xc7, 0xd4, 0x21, 0x5a, + 0x53, 0xdb, 0x99, 0xef, 0xcf, 0x19, 0x9e, 0x7d, 0x26, 0xfe, 0xc7, 0x2d, 0xb4, 0xa8, 0x8f, 0x98, + 0x67, 0xe9, 0xc6, 0x70, 0xc8, 0x28, 0xe7, 0xe4, 0x23, 0x09, 0x68, 0x1c, 0x31, 0xcf, 0x3a, 0x54, + 0x21, 0xfc, 0x14, 0xdd, 0x56, 0x18, 0xdf, 0x9e, 0x50, 0x37, 0xf0, 0x75, 0x4e, 0x2d, 0xd7, 0x19, + 0x72, 0x72, 0xa3, 0xa9, 0xed, 0x2c, 0xf6, 0xb1, 0xc0, 0x9e, 0xa9, 0xd4, 0x40, 0x65, 0xf0, 0x36, + 0x5a, 0x52, 0x14, 0xdb, 0xe1, 0xd4, 0x0a, 0x18, 0x25, 0x33, 0x4d, 0x6d, 0x67, 0xae, 0xbf, 0x20, + 0xb0, 0xdf, 0x85, 0x31, 0xfc, 0x1c, 0xdd, 0x94, 0x8d, 0x40, 0x86, 0x4d, 0x6d, 0xa7, 0xb1, 0x77, + 0xbf, 0x9d, 0x38, 0x0e, 0xed, 0xf0, 0x2b, 0x8e, 0x98, 0x1b, 0x78, 0xc7, 0x02, 0x15, 0x7e, 0x4f, + 0x5f, 0x71, 0xf0, 0x2b, 0x34, 0x17, 0x9d, 0x11, 0x42, 0x25, 0x7f, 0xa7, 0x90, 0x7f, 0x28, 0x81, + 0x27, 0xbd, 0x48, 0x22, 0x66, 0xe2, 0x6f, 0xd0, 0xc7, 0x61, 0x8b, 0x93, 0xb7, 0x52, 0xe4, 0xb3, + 0x62, 0x91, 0x37, 0x83, 0x41, 0x6f, 0x10, 0x49, 0xcc, 0x1a, 0x57, 0x7c, 0x30, 0xe5, 0xb1, 0x80, + 0xc3, 0xc9, 0xa8, 0x86, 0x40, 0x17, 0x0a, 0x38, 0x1c, 0x7f, 0x85, 0x66, 0x44, 0xf7, 0x91, 0x73, + 0xc9, 0xde, 0x2e, 0x64, 0x77, 0x0d, 0x9f, 0x47, 0x5c, 0xc9, 0xc0, 0x67, 0x68, 0x09, 0xf6, 0x2d, + 0xb1, 0xa5, 0xc6, 0x6e, 0xa9, 0xc6, 0x20, 0x42, 0x47, 0x62, 0x8b, 0x4e, 0x32, 0x8a, 0x0f, 0xd0, + 0x0d, 0x87, 0x4f, 0xc9, 0x3b, 0x29, 0x75, 0xaf, 0x58, 0x6a, 0x10, 0xaf, 0xa6, 0xc0, 0xe3, 0xaf, + 0xd1, 0xac, 0xea, 0x69, 0x32, 0xae, 0x58, 0x86, 0xbe, 0x84, 0xc5, 0xcb, 0xa0, 0x58, 0x62, 0x19, + 0xc4, 0xc9, 0x26, 0x17, 0x15, 0xcb, 0x70, 0xd2, 0x3b, 0x3b, 0x8b, 0x97, 0x41, 0x30, 0xf0, 0xcf, + 0xe8, 0x93, 0xcc, 0x3c, 0x24, 0x13, 0x29, 0xd3, 0x29, 0xde, 0x0b, 0xc1, 0x18, 0x28, 0xc2, 0x8b, + 0x20, 0x5e, 0xd8, 0x5b, 0x06, 0x8c, 0xe3, 0x1f, 0xd1, 0xad, 0xd4, 0x18, 0x25, 0x4e, 0xc5, 0x22, + 0x4b, 0xe9, 0x6f, 0x05, 0xfc, 0x75, 0x60, 0xc6, 0x8b, 0x6c, 0x24, 0xa3, 0xf8, 0x35, 0x42, 0xd7, + 0x13, 0x92, 0xb8, 0x52, 0xf1, 0x41, 0xa1, 0xe2, 0xd1, 0xcb, 0xd3, 0xd3, 0xc0, 0x1c, 0x5c, 0xab, + 0xcd, 0x8f, 0x2c, 0xef, 0x54, 0x72, 0x71, 0x17, 0x2d, 0x24, 0x47, 0x26, 0xf1, 0xa4, 0xd6, 0xa3, + 0xe2, 0xa3, 0x14, 0x98, 0xf4, 0xa4, 0xd7, 0x13, 0xd8, 0x48, 0xad, 0xa1, 0x04, 0x64, 0x4c, 0xe8, + 0x25, 0x07, 0x0f, 0x99, 0x56, 0xe8, 0xf5, 0x05, 0x18, 0xba, 0x6b, 0xb0, 0x30, 0x26, 0xfc, 0xf5, + 0xd0, 0x22, 0x98, 0x53, 0x84, 0x49, 0xc1, 0xc7, 0xe5, 0x82, 0xaa, 0x1d, 0xe3, 0x6d, 0x51, 0x96, + 0xc2, 0xa0, 0x68, 0x35, 0x35, 0x74, 0x09, 0xaf, 0x68, 0xb5, 0x53, 0x09, 0x8b, 0x5b, 0x4d, 0xb1, + 0xc4, 0xb9, 0x81, 0xe3, 0x97, 0xf8, 0x15, 0x5b, 0xaa, 0x5a, 0x36, 0x65, 0x6a, 0x91, 0x25, 0xa3, + 0xf1, 0x69, 0x8c, 0x2f, 0x1a, 0x12, 0xd4, 0x38, 0x8d, 0xdf, 0x47, 0x68, 0x70, 0x1a, 0xe3, 0x28, + 0x3e, 0x46, 0x8d, 0xc4, 0x15, 0x4d, 0x2e, 0xa5, 0xe4, 0xc3, 0xb2, 0x11, 0x73, 0xac, 0xa0, 0x91, + 0x1e, 0x32, 0xae, 0x78, 0x18, 0x6a, 0xfd, 0x82, 0x48, 0xd1, 0x54, 0xc5, 0x8f, 0xd0, 0x4d, 0xdd, + 0x72, 0x1d, 0x75, 0x43, 0x34, 0xf6, 0x96, 0xa3, 0x12, 0xe2, 0xa6, 0x69, 0x4b, 0xe4, 0x4b, 0xd7, + 0x71, 0xfa, 0x33, 0xe2, 0x2f, 0xee, 0xa0, 0x19, 0x11, 0x97, 0x97, 0x45, 0x63, 0x6f, 0x3d, 0x8b, + 0x7d, 0xc3, 0x6c, 0x9f, 0x1e, 0xb2, 0x11, 0xef, 0x4b, 0x60, 0xeb, 0x0f, 0x0d, 0xad, 0x97, 0x0c, + 0x64, 0xdc, 0x86, 0xd5, 0x57, 0x81, 0x62, 0x04, 0x4e, 0x18, 0xd8, 0x03, 0x06, 0x36, 0x73, 0xe1, + 0x69, 0x0f, 0xbf, 0xa3, 0xd5, 0xc2, 0x71, 0x8e, 0x1f, 0x43, 0x03, 0x2b, 0x50, 0x51, 0x42, 0x13, + 0xe5, 0x9f, 0x80, 0xf2, 0x77, 0x72, 0xc0, 0x35, 0x8a, 0x77, 0xeb, 0x17, 0xef, 0x7e, 0x48, 0xf1, + 0x6e, 0xa6, 0x78, 0x80, 0x56, 0x0a, 0x6e, 0x12, 0xfc, 0x10, 0x96, 0xbe, 0x0d, 0xd4, 0x04, 0x30, + 0x51, 0xb8, 0x0d, 0x0a, 0xaf, 0x65, 0xa0, 0xe9, 0xb2, 0xff, 0x6a, 0xa8, 0x59, 0xd5, 0xef, 0x78, + 0x1f, 0x1a, 0xd8, 0xcc, 0xa8, 0xc6, 0x8c, 0x84, 0x93, 0x2f, 0x81, 0x93, 0x7b, 0xc5, 0x9c, 0x3a, + 0x96, 0xd2, 0x17, 0x62, 0xb5, 0xa5, 0x98, 0xf1, 0x01, 0x96, 0x62, 0x4e, 0xda, 0x12, 0x43, 0xcb, + 0xf9, 0xf7, 0x2a, 0x7e, 0x00, 0x7d, 0x7c, 0x0a, 0x35, 0x07, 0xc9, 0xf3, 0xb0, 0x0b, 0xaa, 0xaf, + 0xa6, 0x91, 0x15, 0xdd, 0x08, 0x6e, 0xe4, 0xf2, 0x6e, 0x54, 0xd0, 0x9a, 0xdd, 0xa8, 0xc0, 0x55, + 0x7b, 0x90, 0x37, 0x5c, 0xcb, 0xf7, 0x00, 0x30, 0x6a, 0xee, 0x01, 0xe0, 0xa4, 0x2d, 0xfd, 0xad, + 0xa1, 0xcd, 0xf2, 0x4b, 0x0d, 0x3f, 0x85, 0x86, 0x52, 0x1f, 0x7a, 0x8d, 0x4f, 0xd8, 0x39, 0x00, + 0x76, 0xee, 0x16, 0x31, 0xd2, 0x66, 0xfe, 0xd1, 0xd0, 0x56, 0xc5, 0x85, 0x88, 0xf7, 0xa0, 0x9b, + 0x8d, 0xac, 0x76, 0x76, 0x75, 0xbe, 0x00, 0x76, 0x5a, 0x85, 0x94, 0xaa, 0xfd, 0xca, 0x7b, 0xdf, + 0x94, 0xef, 0x17, 0x60, 0xd4, 0xdc, 0x2f, 0xc0, 0x49, 0x5b, 0xfa, 0x4f, 0x43, 0xad, 0xea, 0xd7, + 0x1c, 0x3e, 0x80, 0xa6, 0x9a, 0xd9, 0x02, 0xd7, 0x9c, 0x84, 0xad, 0x67, 0xc0, 0xd6, 0xfd, 0x32, + 0x56, 0xc5, 0xa4, 0x4d, 0x3c, 0x56, 0xcb, 0x27, 0xad, 0x00, 0xd6, 0x9c, 0xb4, 0x02, 0x9a, 0x2e, + 0xfb, 0xa7, 0x86, 0xee, 0x94, 0x3d, 0x18, 0x71, 0x07, 0x16, 0x87, 0x8a, 0x31, 0x3a, 0xe1, 0x60, + 0x1f, 0x38, 0xd8, 0xca, 0xc7, 0x57, 0x1d, 0xa3, 0xec, 0x5b, 0xb3, 0xfc, 0x18, 0x25, 0xf0, 0x35, + 0x8f, 0x51, 0x82, 0x51, 0x31, 0xe3, 0xc0, 0x53, 0xb0, 0x7c, 0xc6, 0x29, 0x68, 0xcd, 0x19, 0xa7, + 0xc0, 0xe9, 0xe2, 0x7f, 0x69, 0x68, 0xa3, 0xf4, 0x5d, 0x86, 0x9f, 0x40, 0x07, 0xeb, 0xe9, 0x6b, + 0x3c, 0x84, 0x27, 0x5c, 0x7c, 0x0e, 0x5c, 0x34, 0x0b, 0x08, 0x29, 0x27, 0x2f, 0x9e, 0xff, 0xf4, + 0x6c, 0x64, 0xfb, 0xe7, 0x81, 0xd9, 0xb6, 0xdc, 0x49, 0xc7, 0x34, 0x7c, 0xeb, 0xdc, 0x72, 0x99, + 0xd7, 0xf1, 0x2e, 0x82, 0x89, 0x49, 0xd9, 0x2e, 0xb7, 0xce, 0xe9, 0xc4, 0xe0, 0x1d, 0x33, 0xb0, + 0x2f, 0x86, 0x9d, 0x91, 0xdb, 0x51, 0xb2, 0x1d, 0xf1, 0xb4, 0x34, 0x67, 0xe5, 0x3f, 0xfb, 0xef, + 0x03, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x9b, 0x20, 0x48, 0xc4, 0x12, 0x00, 0x00, } diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_read.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_read.pb.go index bffd25a8..ecb76a5b 100644 --- a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_read.pb.go +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_read.pb.go @@ -72,7 +72,7 @@ func (x InferSchemaOptions_Type) String() string { } func (InferSchemaOptions_Type) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_ff5a708dd529ae21, []int{23, 0} + return fileDescriptor_ff5a708dd529ae21, []int{24, 0} } type ReadCLIOptions struct { @@ -294,10 +294,12 @@ type ReadOptions struct { // @gotags: kong:"cmd,help='PostgreSQL'" Postgres *ReadGroupPostgresOptions `protobuf:"bytes,117,opt,name=postgres,proto3" json:"postgres,omitempty" kong:"cmd,help='PostgreSQL'"` // @gotags: kong:"cmd,help='NATS Jetstream'" - NatsJetstream *ReadGroupNatsJetstreamOptions `protobuf:"bytes,118,opt,name=nats_jetstream,json=natsJetstream,proto3" json:"nats_jetstream,omitempty" kong:"cmd,help='NATS Jetstream'"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + NatsJetstream *ReadGroupNatsJetstreamOptions `protobuf:"bytes,118,opt,name=nats_jetstream,json=natsJetstream,proto3" json:"nats_jetstream,omitempty" kong:"cmd,help='NATS Jetstream'"` + // @gotags: kong:"cmd,help='AWS Kinesis Streams'" + AwsKinesis *ReadGroupAWSKinesisOptions `protobuf:"bytes,119,opt,name=aws_kinesis,json=awsKinesis,proto3" json:"aws_kinesis,omitempty" kong:"cmd,help='AWS Kinesis Streams'"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ReadOptions) Reset() { *m = ReadOptions{} } @@ -535,6 +537,13 @@ func (m *ReadOptions) GetNatsJetstream() *ReadGroupNatsJetstreamOptions { return nil } +func (m *ReadOptions) GetAwsKinesis() *ReadGroupAWSKinesisOptions { + if m != nil { + return m.AwsKinesis + } + return nil +} + type ReadGroupKafkaOptions struct { // @gotags: kong:"embed" XConn *args.KafkaConn `protobuf:"bytes,1,opt,name=_conn,json=Conn,proto3" json:"_conn,omitempty" kong:"embed"` @@ -1466,6 +1475,55 @@ func (m *ReadGroupKubeMQQueueOptions) GetArgs() *args.KubeMQQueueReadArgs { return nil } +type ReadGroupAWSKinesisOptions struct { + // @gotags: kong:"embed" + XConn *args.AWSKinesisConn `protobuf:"bytes,1,opt,name=_conn,json=Conn,proto3" json:"_conn,omitempty" kong:"embed"` + // @gotags: kong:"embed" + Args *args.AWSKinesisReadArgs `protobuf:"bytes,2,opt,name=args,proto3" json:"args,omitempty" kong:"embed"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReadGroupAWSKinesisOptions) Reset() { *m = ReadGroupAWSKinesisOptions{} } +func (m *ReadGroupAWSKinesisOptions) String() string { return proto.CompactTextString(m) } +func (*ReadGroupAWSKinesisOptions) ProtoMessage() {} +func (*ReadGroupAWSKinesisOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_ff5a708dd529ae21, []int{23} +} + +func (m *ReadGroupAWSKinesisOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ReadGroupAWSKinesisOptions.Unmarshal(m, b) +} +func (m *ReadGroupAWSKinesisOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ReadGroupAWSKinesisOptions.Marshal(b, m, deterministic) +} +func (m *ReadGroupAWSKinesisOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReadGroupAWSKinesisOptions.Merge(m, src) +} +func (m *ReadGroupAWSKinesisOptions) XXX_Size() int { + return xxx_messageInfo_ReadGroupAWSKinesisOptions.Size(m) +} +func (m *ReadGroupAWSKinesisOptions) XXX_DiscardUnknown() { + xxx_messageInfo_ReadGroupAWSKinesisOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_ReadGroupAWSKinesisOptions proto.InternalMessageInfo + +func (m *ReadGroupAWSKinesisOptions) GetXConn() *args.AWSKinesisConn { + if m != nil { + return m.XConn + } + return nil +} + +func (m *ReadGroupAWSKinesisOptions) GetArgs() *args.AWSKinesisReadArgs { + if m != nil { + return m.Args + } + return nil +} + type InferSchemaOptions struct { // Type of schema to infer from the data // @gotags: kong:"-" @@ -1484,7 +1542,7 @@ func (m *InferSchemaOptions) Reset() { *m = InferSchemaOptions{} } func (m *InferSchemaOptions) String() string { return proto.CompactTextString(m) } func (*InferSchemaOptions) ProtoMessage() {} func (*InferSchemaOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_ff5a708dd529ae21, []int{23} + return fileDescriptor_ff5a708dd529ae21, []int{24} } func (m *InferSchemaOptions) XXX_Unmarshal(b []byte) error { @@ -1545,110 +1603,114 @@ func init() { proto.RegisterType((*ReadGroupMQTTOptions)(nil), "protos.opts.ReadGroupMQTTOptions") proto.RegisterType((*ReadGroupGCPPubSubOptions)(nil), "protos.opts.ReadGroupGCPPubSubOptions") proto.RegisterType((*ReadGroupKubeMQQueueOptions)(nil), "protos.opts.ReadGroupKubeMQQueueOptions") + proto.RegisterType((*ReadGroupAWSKinesisOptions)(nil), "protos.opts.ReadGroupAWSKinesisOptions") proto.RegisterType((*InferSchemaOptions)(nil), "protos.opts.InferSchemaOptions") } func init() { proto.RegisterFile("opts/ps_opts_read.proto", fileDescriptor_ff5a708dd529ae21) } var fileDescriptor_ff5a708dd529ae21 = []byte{ - // 1569 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x58, 0xeb, 0x6e, 0xdb, 0xb6, - 0x17, 0xff, 0xbb, 0xcd, 0xf5, 0xb8, 0x76, 0x53, 0x36, 0x17, 0x26, 0x69, 0x6e, 0x6e, 0xfb, 0x47, - 0xda, 0xb5, 0x36, 0x9a, 0xb6, 0x41, 0x87, 0x0e, 0x03, 0xd2, 0x2c, 0xeb, 0xdc, 0x2e, 0x37, 0x29, - 0xbb, 0xa0, 0xc0, 0x20, 0x48, 0x32, 0xe3, 0xa8, 0xb5, 0x25, 0x59, 0x94, 0x5c, 0x64, 0xc0, 0x80, - 0x7d, 0x1a, 0x30, 0x60, 0xd8, 0x87, 0x3d, 0xde, 0x9e, 0x60, 0xdb, 0x53, 0x0c, 0x24, 0x25, 0x59, - 0x94, 0x65, 0xc6, 0xfb, 0x92, 0x58, 0x3c, 0xbf, 0xcb, 0x11, 0xc9, 0xc3, 0x43, 0x1b, 0x96, 0x3c, - 0x3f, 0xa4, 0x0d, 0x9f, 0x1a, 0xec, 0xbf, 0x11, 0x10, 0xb3, 0x55, 0xf7, 0x03, 0x2f, 0xf4, 0x50, - 0x99, 0xff, 0xa3, 0x75, 0x36, 0xbe, 0x52, 0x23, 0xae, 0xed, 0xb5, 0x1c, 0xb7, 0xcd, 0x90, 0xc9, - 0x67, 0x46, 0x71, 0x3c, 0x97, 0x0a, 0xc2, 0xca, 0xaa, 0x19, 0xb4, 0xb9, 0x12, 0xfb, 0x6f, 0x98, - 0x76, 0xe8, 0xf4, 0x49, 0xb7, 0x17, 0x07, 0xef, 0xc9, 0xc1, 0x1f, 0xa3, 0x80, 0x18, 0x94, 0x04, - 0x7d, 0xc7, 0x26, 0x86, 0x15, 0x25, 0x12, 0xb5, 0x02, 0x14, 0xe9, 0x13, 0x37, 0x34, 0x2e, 0x22, - 0x2b, 0xc6, 0xac, 0xc8, 0x98, 0x8f, 0xd4, 0xa0, 0xbd, 0x84, 0xbf, 0x26, 0xc5, 0xda, 0xb6, 0x6f, - 0xf8, 0x91, 0x45, 0x53, 0x2a, 0x96, 0xc2, 0x1f, 0xcc, 0xf3, 0x0f, 0x66, 0x1c, 0xd9, 0x90, 0x23, - 0x91, 0x45, 0xba, 0x3d, 0xa3, 0x17, 0x91, 0x88, 0x14, 0x52, 0xbb, 0x9e, 0xdb, 0xf6, 0xe2, 0xc8, - 0x92, 0x1c, 0xe9, 0x85, 0x61, 0x61, 0xc0, 0x35, 0xc3, 0x24, 0xcb, 0xad, 0xa1, 0x80, 0xf1, 0x9e, - 0x84, 0x34, 0x0c, 0x88, 0xd9, 0x1d, 0x0d, 0x11, 0x71, 0xc7, 0x6d, 0xc7, 0x90, 0x45, 0x19, 0x42, - 0x7b, 0x85, 0xcb, 0xe0, 0x7b, 0x34, 0x6c, 0x07, 0x24, 0xb1, 0x5e, 0x96, 0x83, 0x51, 0x87, 0x9a, - 0x41, 0x61, 0x28, 0x30, 0x2d, 0xcb, 0x09, 0x0b, 0xb3, 0x11, 0xa1, 0x38, 0x1f, 0x5a, 0x38, 0x81, - 0x01, 0x69, 0x39, 0x54, 0x9e, 0xfb, 0xcd, 0x02, 0x80, 0x24, 0x51, 0xb3, 0xa1, 0xaa, 0x11, 0xb3, - 0xb5, 0xff, 0x75, 0xf3, 0x58, 0xec, 0x2b, 0x74, 0x1f, 0xaa, 0x7d, 0x12, 0x58, 0x1e, 0x25, 0x86, - 0x17, 0x85, 0x7e, 0x14, 0xe2, 0xd2, 0x66, 0x69, 0x7b, 0x46, 0xab, 0xc4, 0xa3, 0xc7, 0x7c, 0x10, - 0x2d, 0xc2, 0x94, 0x1f, 0x90, 0x30, 0xbc, 0xc4, 0xd7, 0x78, 0x38, 0x7e, 0x42, 0x08, 0x26, 0xde, - 0x53, 0xcf, 0xc5, 0xd7, 0xf9, 0x28, 0xff, 0x5c, 0xeb, 0xc0, 0x2d, 0x66, 0xa2, 0x9b, 0x5d, 0xbf, - 0x43, 0x12, 0x9f, 0x0d, 0x28, 0x53, 0x3e, 0x60, 0x04, 0x66, 0x48, 0xb8, 0x49, 0x45, 0x03, 0x31, - 0xa4, 0x99, 0x21, 0x41, 0xbb, 0xb0, 0x14, 0x03, 0x1c, 0x37, 0x24, 0x41, 0xdf, 0xec, 0x18, 0x94, - 0xd8, 0x9e, 0xdb, 0xa2, 0xdc, 0xb2, 0xa2, 0x2d, 0x88, 0x70, 0x33, 0x8e, 0xea, 0x22, 0x58, 0x7b, - 0x20, 0xdc, 0xbe, 0x74, 0x3a, 0x21, 0x09, 0x12, 0xb7, 0x79, 0x98, 0xec, 0x45, 0x24, 0xb8, 0xe4, - 0x3e, 0xb3, 0x9a, 0x78, 0xa8, 0xfd, 0x59, 0x85, 0x32, 0xc3, 0x26, 0x28, 0x04, 0x13, 0xae, 0xd9, - 0x25, 0x31, 0x88, 0x7f, 0x46, 0x77, 0xa1, 0x62, 0x7b, 0xae, 0x4b, 0x6c, 0x06, 0x31, 0x9c, 0x16, - 0x37, 0x9f, 0xd5, 0x6e, 0x0c, 0x06, 0x9b, 0x2d, 0xb4, 0x0e, 0x60, 0x7b, 0x6e, 0xe8, 0xb8, 0x91, - 0x17, 0xd1, 0xf8, 0xdd, 0x33, 0x23, 0xe8, 0x00, 0xaa, 0xf1, 0xbb, 0xc4, 0xe5, 0x8b, 0x27, 0x36, - 0x4b, 0xdb, 0xe5, 0x9d, 0xf5, 0x7a, 0xa6, 0xe0, 0xeb, 0x43, 0x93, 0xa4, 0x55, 0xa8, 0x34, 0x67, - 0x07, 0x50, 0x6d, 0x11, 0xdb, 0x6b, 0x0d, 0x64, 0x26, 0x65, 0x99, 0xe4, 0x94, 0xa8, 0x7f, 0xc1, - 0x61, 0xa9, 0x4c, 0x2b, 0xfb, 0x88, 0xf6, 0xa0, 0x6a, 0x7b, 0x6e, 0x9f, 0x04, 0x61, 0xb2, 0xc4, - 0x53, 0x9b, 0xa5, 0xed, 0xea, 0xce, 0x8a, 0x94, 0xcd, 0xbe, 0x80, 0x08, 0x92, 0x56, 0x89, 0x19, - 0xf1, 0xf2, 0xef, 0xc2, 0xd4, 0x39, 0x9f, 0x60, 0x3c, 0x3d, 0xe2, 0x45, 0xa4, 0xf9, 0xd7, 0x62, - 0x34, 0x3a, 0x85, 0x79, 0xc7, 0x3d, 0x27, 0x81, 0x41, 0xed, 0x0b, 0xd2, 0x35, 0xd3, 0xf7, 0x98, - 0xe1, 0x2a, 0x1b, 0x92, 0x4a, 0x93, 0x01, 0x75, 0x8e, 0x4b, 0x64, 0x90, 0x33, 0x34, 0x86, 0xe6, - 0xe0, 0x3a, 0x5b, 0x96, 0xbf, 0xa6, 0xf9, 0xba, 0x5c, 0x6b, 0xb6, 0x10, 0x86, 0xe9, 0xf8, 0x28, - 0xc4, 0x7f, 0x4f, 0x8b, 0xdd, 0xb9, 0xc7, 0x1f, 0xd1, 0xe7, 0x70, 0xc3, 0xb0, 0x3b, 0x4e, 0x6a, - 0xfb, 0x8f, 0xc8, 0x7e, 0x75, 0x28, 0xfb, 0x41, 0x41, 0x68, 0xb0, 0xdf, 0x71, 0x12, 0xaf, 0x17, - 0x30, 0xc9, 0x4f, 0x30, 0xdc, 0xe2, 0xbc, 0xda, 0x10, 0xef, 0x75, 0xe0, 0x45, 0xfe, 0x5b, 0x06, - 0x49, 0xe8, 0x82, 0x80, 0xf6, 0x60, 0x26, 0x39, 0x9d, 0x31, 0xe1, 0xe4, 0xfb, 0xc5, 0x64, 0x91, - 0xe9, 0xe1, 0x69, 0xc2, 0x4f, 0x69, 0xe8, 0x33, 0x98, 0x8e, 0x4f, 0x5e, 0x7c, 0xce, 0x15, 0xee, - 0x8e, 0x50, 0xf8, 0x4e, 0xd7, 0x4f, 0xf5, 0x74, 0xe6, 0xcd, 0x8f, 0x54, 0xef, 0xf1, 0xd4, 0xf9, - 0x09, 0x8a, 0xdb, 0xaa, 0xd4, 0x0f, 0x19, 0x24, 0x4d, 0x9d, 0x13, 0xd0, 0x73, 0x56, 0x15, 0x21, - 0xc5, 0x17, 0x9c, 0xb8, 0x55, 0x4c, 0x3c, 0x32, 0x43, 0x9a, 0xf0, 0x38, 0x1c, 0x9d, 0x42, 0x55, - 0x3e, 0x43, 0xb1, 0xc3, 0x05, 0x1e, 0x8e, 0x16, 0xd0, 0x13, 0x68, 0xba, 0x71, 0xdd, 0xec, 0x28, - 0xda, 0x81, 0xeb, 0x2e, 0xed, 0xe1, 0xf7, 0x5c, 0x67, 0x73, 0x84, 0x8e, 0x9e, 0x4e, 0x1d, 0x03, - 0xa3, 0x97, 0x30, 0x25, 0x8e, 0x5c, 0xfc, 0x41, 0x35, 0x69, 0x27, 0x1c, 0x93, 0x4e, 0x9a, 0xa0, - 0x30, 0xb2, 0x38, 0x79, 0x71, 0x47, 0x45, 0xd6, 0x38, 0x26, 0x25, 0x0b, 0x0a, 0x9b, 0x00, 0xf9, - 0xd8, 0xc6, 0x5d, 0xd5, 0x04, 0x08, 0x11, 0xf1, 0xb2, 0xe9, 0x54, 0x56, 0x82, 0xec, 0x28, 0x5b, - 0x0a, 0xd6, 0xec, 0xb0, 0xab, 0x5a, 0x8a, 0xc3, 0xd3, 0xb3, 0xb3, 0x74, 0x29, 0x18, 0x1c, 0x7d, - 0x0f, 0xb7, 0x86, 0xba, 0x3f, 0xf6, 0xb8, 0xc6, 0xa3, 0x11, 0x7b, 0x88, 0xc1, 0x75, 0x81, 0x7e, - 0x15, 0xa5, 0xe9, 0xdc, 0x34, 0xe5, 0x71, 0xa4, 0xc1, 0xcd, 0xdc, 0x8d, 0x01, 0xfb, 0xaa, 0x97, - 0xe4, 0xba, 0x07, 0x0c, 0xfb, 0x55, 0x64, 0xa5, 0x2f, 0x69, 0x66, 0x47, 0xd1, 0x01, 0xc0, 0xe0, - 0x16, 0x81, 0x7b, 0x5c, 0xee, 0xff, 0xc5, 0x72, 0xaf, 0xf7, 0x4f, 0x4e, 0x22, 0x4b, 0x1f, 0x48, - 0xcd, 0xb6, 0x6d, 0xff, 0x84, 0x13, 0xd1, 0x5b, 0xb8, 0x91, 0xbd, 0x53, 0xe0, 0x80, 0x0b, 0x6d, - 0x8f, 0x28, 0xd9, 0xc8, 0x22, 0x87, 0xa7, 0xa7, 0x0c, 0x98, 0x48, 0x95, 0x05, 0x9b, 0x8f, 0x31, - 0xb1, 0x6c, 0x7f, 0xc5, 0x54, 0x25, 0xa6, 0x31, 0xa4, 0x9c, 0x57, 0x39, 0x88, 0xc7, 0x58, 0x66, - 0x47, 0x50, 0x91, 0x7a, 0x31, 0x0e, 0xb9, 0xda, 0x03, 0x85, 0x5a, 0x6e, 0x5b, 0x88, 0x64, 0x92, - 0x5d, 0xb1, 0x07, 0x33, 0xc9, 0x95, 0x03, 0x47, 0xaa, 0xb3, 0xe5, 0x24, 0x46, 0xa5, 0x67, 0x4b, - 0x42, 0x4b, 0x8b, 0x35, 0xbd, 0x13, 0xe1, 0xfe, 0x55, 0xc5, 0xfa, 0x26, 0x81, 0x4a, 0xc5, 0x9a, - 0x8e, 0xd6, 0x42, 0x58, 0x28, 0x3c, 0x11, 0xd1, 0x27, 0x30, 0x69, 0xb0, 0xee, 0xc9, 0xdb, 0x6c, - 0x79, 0x67, 0x31, 0xb1, 0x60, 0x97, 0x94, 0x3a, 0x47, 0xee, 0x7b, 0xae, 0xab, 0x4d, 0xb0, 0xbf, - 0xa8, 0x0e, 0x13, 0x6c, 0x9c, 0x77, 0xdd, 0xf2, 0xa0, 0x43, 0x0d, 0xb0, 0xcc, 0x63, 0x2f, 0x68, - 0x53, 0x8d, 0xe3, 0x6a, 0x3f, 0x01, 0x1e, 0x75, 0x94, 0xa2, 0xba, 0x6c, 0xbc, 0x2c, 0x89, 0x25, - 0xe0, 0x8c, 0xf7, 0x13, 0xc9, 0x7b, 0xad, 0x10, 0x9e, 0xb3, 0xff, 0x08, 0x8b, 0xc5, 0xe7, 0x30, - 0x7a, 0x24, 0x9b, 0x2f, 0xc9, 0x6a, 0x1c, 0x9a, 0xb1, 0x6e, 0x48, 0xd6, 0xab, 0x05, 0xe0, 0x9c, - 0x71, 0x76, 0xb6, 0xb3, 0x87, 0xb8, 0x7a, 0xb6, 0x39, 0x72, 0xcc, 0xd9, 0xe6, 0xd8, 0x9c, 0x6b, - 0x0f, 0xe6, 0x8b, 0x3a, 0x00, 0x7a, 0x28, 0x9b, 0x2e, 0x48, 0x42, 0x0c, 0x98, 0xf1, 0x7c, 0x2c, - 0x79, 0x2e, 0x0f, 0x41, 0x73, 0x96, 0xbf, 0x95, 0x60, 0x4d, 0xd9, 0x34, 0xd0, 0x53, 0xd9, 0x7c, - 0x7d, 0x48, 0x31, 0x65, 0x64, 0xb2, 0xd8, 0x95, 0xb2, 0xa8, 0x8d, 0xe6, 0x5c, 0x95, 0x4e, 0xbe, - 0x2c, 0xae, 0x4e, 0x27, 0x65, 0xfc, 0x87, 0x74, 0x52, 0x4e, 0x2e, 0x1d, 0x17, 0x6e, 0x17, 0x74, - 0x42, 0xf4, 0x40, 0xce, 0x61, 0x5e, 0xd6, 0xd3, 0xb3, 0x9b, 0xfe, 0x91, 0xe4, 0x8c, 0xf3, 0x48, - 0x45, 0xb9, 0xe5, 0x4e, 0x17, 0x75, 0xb9, 0x25, 0xe0, 0x31, 0xcb, 0x2d, 0x81, 0x2b, 0xca, 0x4d, - 0xea, 0xe0, 0xea, 0x72, 0x13, 0xd0, 0x31, 0xcb, 0x4d, 0x80, 0x15, 0xc6, 0x52, 0xf7, 0x57, 0x1b, - 0x0b, 0xe8, 0x98, 0xc6, 0x02, 0xac, 0xda, 0x6f, 0x45, 0x57, 0x06, 0xf5, 0x7e, 0x93, 0x18, 0x63, - 0xee, 0x37, 0x89, 0x93, 0x4b, 0xe7, 0x97, 0x12, 0xac, 0x2a, 0xfa, 0x1e, 0x7a, 0x22, 0x27, 0x73, - 0x47, 0x16, 0x1e, 0xe0, 0x33, 0xa9, 0x3c, 0x93, 0x52, 0xd9, 0x1c, 0xc5, 0xc8, 0x25, 0xf2, 0x6b, - 0x09, 0xee, 0xa8, 0x5a, 0x26, 0xda, 0x91, 0x33, 0x59, 0x1b, 0xd6, 0x1d, 0x9e, 0x95, 0xe7, 0x52, - 0x2a, 0x5b, 0x23, 0x29, 0xaa, 0x35, 0x2a, 0xba, 0xf1, 0xa8, 0xd7, 0x48, 0x62, 0x8c, 0xb9, 0x46, - 0x12, 0x27, 0x97, 0xce, 0x1f, 0x25, 0xd8, 0xb8, 0xe2, 0x62, 0x87, 0x9e, 0xcb, 0x09, 0x6d, 0x0e, - 0x8b, 0x0f, 0x38, 0x99, 0x94, 0x5e, 0x48, 0x29, 0xdd, 0x53, 0xb1, 0x14, 0x9d, 0x23, 0x73, 0x61, - 0x55, 0x77, 0x0e, 0x06, 0x1c, 0xb3, 0x73, 0x30, 0x68, 0xce, 0xf2, 0xe7, 0x12, 0x2c, 0x8f, 0xbc, - 0x39, 0xa2, 0x86, 0x6c, 0x2c, 0xf7, 0xbe, 0x14, 0x9d, 0x71, 0xdf, 0x91, 0xdc, 0xd7, 0x8b, 0xf1, - 0xaa, 0x72, 0x19, 0xbe, 0x73, 0xaa, 0xcb, 0x25, 0x83, 0x1f, 0xb3, 0x5c, 0x32, 0x8c, 0x5c, 0x22, - 0xbf, 0x97, 0x00, 0x0d, 0x7f, 0xbf, 0x66, 0xeb, 0x19, 0x5e, 0xfa, 0xe2, 0x07, 0x90, 0xea, 0x60, - 0x3d, 0x47, 0x7c, 0x1d, 0xaf, 0x9f, 0x5d, 0xfa, 0x44, 0xe3, 0x0c, 0xb4, 0x0a, 0xb3, 0xf1, 0x57, - 0xfa, 0xf4, 0x27, 0x92, 0x19, 0x31, 0xd0, 0x6c, 0xd5, 0xb6, 0x60, 0x82, 0x41, 0xd1, 0x2c, 0x4c, - 0x7e, 0x73, 0xa4, 0x1f, 0x9c, 0xcd, 0xfd, 0x0f, 0x55, 0x01, 0xde, 0xe8, 0xc7, 0x47, 0x42, 0x6f, - 0xae, 0xf4, 0xf0, 0x07, 0xa8, 0x48, 0x3f, 0x38, 0x20, 0x0c, 0xf3, 0xfb, 0xc7, 0x47, 0xdf, 0x1e, - 0x68, 0x67, 0xc6, 0xf1, 0xc9, 0x59, 0xf3, 0xf8, 0xc8, 0x48, 0xa8, 0xcb, 0xb0, 0x90, 0x8b, 0xbc, - 0xda, 0xd3, 0x0f, 0x76, 0x9f, 0xcd, 0x95, 0xd0, 0x12, 0xdc, 0xce, 0x85, 0x5e, 0xbf, 0x6b, 0x9e, - 0xcc, 0x5d, 0x7b, 0xf5, 0xf2, 0xdd, 0xa7, 0x6d, 0x27, 0xbc, 0x88, 0xac, 0xba, 0xed, 0x75, 0x1b, - 0x96, 0x19, 0xda, 0x17, 0xb6, 0x17, 0xf8, 0x0d, 0xbf, 0x13, 0x75, 0x2d, 0x12, 0x3c, 0x16, 0xa9, - 0xd2, 0x86, 0x15, 0x39, 0x9d, 0x56, 0xa3, 0xed, 0x35, 0xc4, 0x9b, 0x37, 0xd8, 0x9b, 0x5b, 0x53, - 0xfc, 0xe1, 0xe9, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x38, 0xb8, 0xcf, 0xb7, 0x15, 0x00, - 0x00, + // 1629 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x58, 0x6b, 0x6f, 0xdb, 0x46, + 0x16, 0x5d, 0x25, 0x7e, 0x5e, 0x45, 0x8a, 0x33, 0xf1, 0x63, 0x6c, 0xc7, 0x2f, 0x25, 0xd9, 0x75, + 0xb2, 0x89, 0xb4, 0x71, 0x12, 0x23, 0x8b, 0x2c, 0x16, 0x70, 0xbc, 0xde, 0x44, 0x49, 0xfd, 0x22, + 0xdd, 0x07, 0x02, 0x14, 0x04, 0x49, 0x8d, 0x65, 0xc6, 0x12, 0x49, 0x71, 0x48, 0x1b, 0x2e, 0x50, + 0xa0, 0x40, 0x81, 0x02, 0x05, 0x8a, 0x7e, 0xe8, 0x6f, 0xe8, 0x8f, 0x6b, 0xfb, 0x2b, 0x8a, 0x99, + 0x21, 0x29, 0x0e, 0x5f, 0x56, 0xbf, 0xd8, 0xe2, 0xbd, 0xe7, 0x9c, 0x7b, 0x38, 0x8f, 0x3b, 0x03, + 0xc2, 0x82, 0xe3, 0xfa, 0xb4, 0xe5, 0x52, 0x8d, 0xfd, 0xd7, 0x3c, 0xa2, 0x77, 0x9a, 0xae, 0xe7, + 0xf8, 0x0e, 0xaa, 0xf2, 0x7f, 0xb4, 0xc9, 0xe2, 0x4b, 0x0d, 0x62, 0x9b, 0x4e, 0xc7, 0xb2, 0xbb, + 0x0c, 0x19, 0xfd, 0x66, 0x14, 0xcb, 0xb1, 0xa9, 0x20, 0x2c, 0x2d, 0xeb, 0x5e, 0x97, 0x2b, 0xb1, + 0xff, 0x9a, 0x6e, 0xfa, 0xd6, 0x05, 0xe9, 0x0f, 0xc2, 0xe4, 0x03, 0x39, 0xf9, 0x4d, 0xe0, 0x11, + 0x8d, 0x12, 0xef, 0xc2, 0x32, 0x89, 0x66, 0x04, 0x91, 0x44, 0x23, 0x07, 0x45, 0x2e, 0x88, 0xed, + 0x6b, 0x67, 0x81, 0x11, 0x62, 0x96, 0x64, 0xcc, 0x25, 0xd5, 0xe8, 0x20, 0xe2, 0xaf, 0x66, 0x72, + 0xe7, 0x96, 0x4d, 0xa8, 0x15, 0xe5, 0x57, 0xa4, 0x7c, 0xd7, 0x74, 0x35, 0x37, 0x30, 0x68, 0x2c, + 0x8d, 0xa5, 0xf4, 0xb9, 0x7e, 0x7a, 0xae, 0x87, 0x99, 0x35, 0x39, 0x13, 0x18, 0xa4, 0x3f, 0xd0, + 0x06, 0x01, 0x09, 0x48, 0x2e, 0xb5, 0xef, 0xd8, 0x5d, 0x27, 0xcc, 0x2c, 0xc8, 0x99, 0x81, 0xef, + 0xe7, 0x26, 0x6c, 0xdd, 0x8f, 0x5c, 0x6e, 0x64, 0x12, 0xda, 0x27, 0xe2, 0x53, 0xdf, 0x23, 0x7a, + 0xbf, 0x18, 0x22, 0xf2, 0x96, 0xdd, 0x0d, 0x21, 0xf3, 0x32, 0x84, 0x0e, 0x72, 0xa7, 0xc9, 0x75, + 0xa8, 0xdf, 0xf5, 0x48, 0x54, 0x7a, 0x51, 0x4e, 0x06, 0x3d, 0xaa, 0x7b, 0xb9, 0x29, 0x4f, 0x37, + 0x0c, 0xcb, 0xcf, 0x75, 0x23, 0x52, 0xa1, 0x1f, 0x9a, 0x3b, 0x80, 0x1e, 0xe9, 0x58, 0x54, 0x1e, + 0xfb, 0xf5, 0x1c, 0x80, 0x24, 0xd1, 0x30, 0xa1, 0xae, 0x10, 0xbd, 0xb3, 0xfb, 0x59, 0xfb, 0x50, + 0xac, 0x3b, 0xf4, 0x10, 0xea, 0x17, 0xc4, 0x33, 0x1c, 0x4a, 0x34, 0x27, 0xf0, 0xdd, 0xc0, 0xc7, + 0x95, 0xf5, 0xca, 0xe6, 0x94, 0x52, 0x0b, 0xa3, 0x87, 0x3c, 0x88, 0xe6, 0x61, 0xc2, 0xf5, 0x88, + 0xef, 0x5f, 0xe1, 0x1b, 0x3c, 0x1d, 0x3e, 0x21, 0x04, 0x63, 0x9f, 0xa8, 0x63, 0xe3, 0x9b, 0x3c, + 0xca, 0x7f, 0x37, 0x7a, 0x70, 0x87, 0x15, 0x51, 0xf5, 0xbe, 0xdb, 0x23, 0x51, 0x9d, 0x35, 0xa8, + 0x52, 0x1e, 0xd0, 0x3c, 0xdd, 0x27, 0xbc, 0x48, 0x4d, 0x01, 0x11, 0x52, 0x74, 0x9f, 0xa0, 0x6d, + 0x58, 0x08, 0x01, 0x96, 0xed, 0x13, 0xef, 0x42, 0xef, 0x69, 0x94, 0x98, 0x8e, 0xdd, 0xa1, 0xbc, + 0x64, 0x4d, 0x99, 0x13, 0xe9, 0x76, 0x98, 0x55, 0x45, 0xb2, 0xf1, 0x48, 0x54, 0xfb, 0xbf, 0xd5, + 0xf3, 0x89, 0x17, 0x55, 0x9b, 0x85, 0xf1, 0x41, 0x40, 0xbc, 0x2b, 0x5e, 0x67, 0x5a, 0x11, 0x0f, + 0x8d, 0x5f, 0x6f, 0x43, 0x95, 0x61, 0x23, 0x14, 0x82, 0x31, 0x5b, 0xef, 0x93, 0x10, 0xc4, 0x7f, + 0xa3, 0xfb, 0x50, 0x33, 0x1d, 0xdb, 0x26, 0x26, 0x83, 0x68, 0x56, 0x87, 0x17, 0x9f, 0x56, 0x6e, + 0x0d, 0x83, 0xed, 0x0e, 0x5a, 0x05, 0x30, 0x1d, 0xdb, 0xb7, 0xec, 0xc0, 0x09, 0x68, 0xf8, 0xee, + 0x89, 0x08, 0xda, 0x83, 0x7a, 0xf8, 0x2e, 0xe1, 0xf6, 0xc6, 0x63, 0xeb, 0x95, 0xcd, 0xea, 0xd6, + 0x6a, 0x33, 0xd1, 0x10, 0x9a, 0x99, 0x41, 0x52, 0x6a, 0x54, 0x1a, 0xb3, 0x3d, 0xa8, 0x77, 0x88, + 0xe9, 0x74, 0x86, 0x32, 0xe3, 0xb2, 0x4c, 0xd4, 0x45, 0x9a, 0xff, 0xe3, 0xb0, 0x58, 0xa6, 0x93, + 0x7c, 0x44, 0x3b, 0x50, 0x37, 0x1d, 0xfb, 0x82, 0x78, 0x7e, 0x34, 0xc5, 0x13, 0xeb, 0x95, 0xcd, + 0xfa, 0xd6, 0x92, 0xe4, 0x66, 0x57, 0x40, 0x04, 0x49, 0xa9, 0x85, 0x8c, 0x70, 0xfa, 0xb7, 0x61, + 0xe2, 0x94, 0x0f, 0x30, 0x9e, 0x2c, 0x78, 0x11, 0x69, 0xfc, 0x95, 0x10, 0x8d, 0x8e, 0x61, 0xd6, + 0xb2, 0x4f, 0x89, 0xa7, 0x51, 0xf3, 0x8c, 0xf4, 0xf5, 0xf8, 0x3d, 0xa6, 0xb8, 0xca, 0x9a, 0xa4, + 0xd2, 0x66, 0x40, 0x95, 0xe3, 0x22, 0x19, 0x64, 0x65, 0x62, 0x68, 0x06, 0x6e, 0xb2, 0x69, 0xf9, + 0x6d, 0x92, 0xcf, 0xcb, 0x8d, 0x76, 0x07, 0x61, 0x98, 0x0c, 0x5b, 0x25, 0xfe, 0x7d, 0x52, 0xac, + 0xce, 0x1d, 0xfe, 0x88, 0xfe, 0x0b, 0xb7, 0x34, 0xb3, 0x67, 0xc5, 0x65, 0xff, 0x10, 0xee, 0x97, + 0x33, 0xee, 0x87, 0x1b, 0x42, 0x81, 0xdd, 0x9e, 0x15, 0xd5, 0x7a, 0x05, 0xe3, 0xbc, 0x83, 0xe1, + 0x0e, 0xe7, 0x35, 0x32, 0xbc, 0xb7, 0x9e, 0x13, 0xb8, 0x1f, 0x18, 0x24, 0xa2, 0x0b, 0x02, 0xda, + 0x81, 0xa9, 0xa8, 0x7b, 0x63, 0xc2, 0xc9, 0x0f, 0xf3, 0xc9, 0xc2, 0xe9, 0xfe, 0x71, 0xc4, 0x8f, + 0x69, 0xe8, 0x3f, 0x30, 0x19, 0x76, 0x66, 0x7c, 0xca, 0x15, 0xee, 0x17, 0x28, 0x7c, 0xa9, 0xaa, + 0xc7, 0x6a, 0x3c, 0xf2, 0xfa, 0x25, 0x55, 0x07, 0xdc, 0x3a, 0xef, 0xa0, 0xb8, 0x5b, 0x66, 0x7d, + 0x9f, 0x41, 0x62, 0xeb, 0x9c, 0x80, 0x5e, 0xb2, 0x5d, 0xe1, 0x53, 0x7c, 0xc6, 0x89, 0x1b, 0xf9, + 0xc4, 0x03, 0xdd, 0xa7, 0x11, 0x8f, 0xc3, 0xd1, 0x31, 0xd4, 0xe5, 0x1e, 0x8a, 0x2d, 0x2e, 0xf0, + 0xb8, 0x58, 0x40, 0x8d, 0xa0, 0xf1, 0xc2, 0xb5, 0x93, 0x51, 0xb4, 0x05, 0x37, 0x6d, 0x3a, 0xc0, + 0x9f, 0xb8, 0xce, 0x7a, 0x81, 0x8e, 0x1a, 0x0f, 0x1d, 0x03, 0xa3, 0xd7, 0x30, 0x21, 0x5a, 0x2e, + 0x3e, 0x2f, 0x1b, 0xb4, 0x23, 0x8e, 0x89, 0x07, 0x4d, 0x50, 0x18, 0x59, 0x74, 0x5e, 0xdc, 0x2b, + 0x23, 0x2b, 0x1c, 0x13, 0x93, 0x05, 0x85, 0x0d, 0x80, 0xdc, 0xb6, 0x71, 0xbf, 0x6c, 0x00, 0x84, + 0x88, 0x78, 0xd9, 0x78, 0x28, 0x6b, 0x5e, 0x32, 0xca, 0xa6, 0x82, 0x1d, 0x76, 0xd8, 0x2e, 0x9b, + 0x8a, 0xfd, 0xe3, 0x93, 0x93, 0x78, 0x2a, 0x18, 0x1c, 0x7d, 0x05, 0x77, 0x32, 0xb7, 0x03, 0xec, + 0x70, 0x8d, 0x27, 0x05, 0x6b, 0x88, 0xc1, 0x55, 0x81, 0x7e, 0x13, 0xc4, 0x76, 0x6e, 0xeb, 0x72, + 0x1c, 0x29, 0x70, 0x3b, 0x75, 0xa3, 0xc0, 0x6e, 0xd9, 0x4b, 0x72, 0xdd, 0x3d, 0x86, 0x7d, 0x17, + 0x18, 0xf1, 0x4b, 0xea, 0xc9, 0x28, 0xda, 0x03, 0x18, 0xde, 0x22, 0xf0, 0x80, 0xcb, 0xfd, 0x3d, + 0x5f, 0xee, 0xed, 0xee, 0xd1, 0x51, 0x60, 0xa8, 0x43, 0xa9, 0xe9, 0xae, 0xe9, 0x1e, 0x71, 0x22, + 0xfa, 0x00, 0xb7, 0x92, 0x77, 0x0a, 0xec, 0x71, 0xa1, 0xcd, 0x82, 0x2d, 0x1b, 0x18, 0x64, 0xff, + 0xf8, 0x98, 0x01, 0x23, 0xa9, 0xaa, 0x60, 0xf3, 0x18, 0x13, 0x4b, 0x9e, 0xaf, 0x98, 0x96, 0x89, + 0x29, 0x0c, 0x29, 0xfb, 0xaa, 0x7a, 0x61, 0x8c, 0x39, 0x3b, 0x80, 0x9a, 0x74, 0x16, 0x63, 0x9f, + 0xab, 0x3d, 0x2a, 0x51, 0x4b, 0x2d, 0x0b, 0x61, 0x26, 0x5a, 0x15, 0x3b, 0x30, 0x15, 0x5d, 0x39, + 0x70, 0x50, 0xd6, 0x5b, 0x8e, 0x42, 0x54, 0xdc, 0x5b, 0x22, 0x5a, 0xbc, 0x59, 0xe3, 0x3b, 0x11, + 0xbe, 0xb8, 0x6e, 0xb3, 0xbe, 0x8f, 0xa0, 0xd2, 0x66, 0x8d, 0xa3, 0xe8, 0x1d, 0x54, 0x13, 0x97, + 0x45, 0x7c, 0xc9, 0xf5, 0xfe, 0x51, 0xd8, 0xb2, 0x3e, 0x08, 0x5c, 0xdc, 0x75, 0xf5, 0x4b, 0x1a, + 0x86, 0x1a, 0x3e, 0xcc, 0xe5, 0xf6, 0x56, 0xf4, 0x4f, 0x18, 0xd7, 0xd8, 0x39, 0xcc, 0x0f, 0xec, + 0xea, 0xd6, 0x7c, 0x24, 0xce, 0xae, 0x3b, 0x4d, 0x8e, 0xdc, 0x75, 0x6c, 0x5b, 0x19, 0x63, 0x7f, + 0x51, 0x13, 0xc6, 0x58, 0x9c, 0x9f, 0xdf, 0xd5, 0xe1, 0x59, 0x37, 0xc4, 0xb2, 0x1a, 0x3b, 0x5e, + 0x97, 0x2a, 0x1c, 0xd7, 0xf8, 0x16, 0x70, 0x51, 0x53, 0x46, 0x4d, 0xb9, 0xf0, 0xa2, 0x24, 0x16, + 0x81, 0x13, 0xb5, 0x9f, 0x49, 0xb5, 0x57, 0x72, 0xe1, 0xa9, 0xf2, 0x97, 0x30, 0x9f, 0xdf, 0xd1, + 0xd1, 0x13, 0xb9, 0xf8, 0x82, 0xac, 0xc6, 0xa1, 0x89, 0xd2, 0x2d, 0xa9, 0xf4, 0x72, 0x0e, 0x38, + 0x55, 0x38, 0x39, 0xda, 0xc9, 0xe3, 0xa0, 0x7c, 0xb4, 0x39, 0x72, 0xc4, 0xd1, 0xe6, 0xd8, 0x54, + 0xd5, 0x01, 0xcc, 0xe6, 0x9d, 0x25, 0xe8, 0xb1, 0x5c, 0x74, 0x4e, 0x12, 0x62, 0xc0, 0x44, 0xcd, + 0xa7, 0x52, 0xcd, 0xc5, 0x0c, 0x34, 0x55, 0xf2, 0xa7, 0x0a, 0xac, 0x94, 0x1e, 0x3f, 0xe8, 0xb9, + 0x5c, 0x7c, 0x35, 0xa3, 0x18, 0x33, 0x12, 0x2e, 0xb6, 0x25, 0x17, 0x8d, 0x62, 0xce, 0x75, 0x76, + 0xd2, 0x1b, 0xec, 0x7a, 0x3b, 0x31, 0xe3, 0x2f, 0xd8, 0x89, 0x39, 0x29, 0x3b, 0x36, 0xdc, 0xcd, + 0x39, 0x53, 0xd1, 0x23, 0xd9, 0xc3, 0xac, 0xac, 0xa7, 0x26, 0x17, 0xfd, 0x13, 0xa9, 0x32, 0x4e, + 0x23, 0x4b, 0xb6, 0x5b, 0xaa, 0x4f, 0x95, 0x6f, 0xb7, 0x08, 0x3c, 0xe2, 0x76, 0x8b, 0xe0, 0x25, + 0xdb, 0x4d, 0xba, 0x0b, 0x94, 0x6f, 0x37, 0x01, 0x1d, 0x71, 0xbb, 0x09, 0x70, 0x49, 0x61, 0xe9, + 0x1e, 0x51, 0x5e, 0x58, 0x40, 0x47, 0x2c, 0x2c, 0xc0, 0x65, 0xeb, 0x2d, 0xef, 0xf2, 0x51, 0xbe, + 0xde, 0x24, 0xc6, 0x88, 0xeb, 0x4d, 0xe2, 0xa4, 0xec, 0xfc, 0x50, 0x81, 0xe5, 0x92, 0x13, 0x14, + 0x3d, 0x93, 0xcd, 0xdc, 0x93, 0x85, 0x87, 0xf8, 0x84, 0x95, 0x17, 0x92, 0x95, 0xf5, 0x22, 0x46, + 0xca, 0xc8, 0x8f, 0x15, 0xb8, 0x57, 0x76, 0xf8, 0xa2, 0x2d, 0xd9, 0xc9, 0x4a, 0x56, 0x37, 0x3b, + 0x2a, 0x2f, 0x25, 0x2b, 0x1b, 0x85, 0x94, 0xb2, 0x39, 0xca, 0xbb, 0x3b, 0x95, 0xcf, 0x91, 0xc4, + 0x18, 0x71, 0x8e, 0x24, 0x4e, 0xca, 0xce, 0x2f, 0x15, 0x58, 0xbb, 0xe6, 0x8a, 0x88, 0x5e, 0xca, + 0x86, 0xd6, 0xb3, 0xe2, 0x43, 0x4e, 0xc2, 0xd2, 0x2b, 0xc9, 0xd2, 0x83, 0x32, 0x56, 0xc9, 0xc9, + 0x91, 0xb8, 0xfa, 0x96, 0x9f, 0x1c, 0x0c, 0x38, 0xe2, 0xc9, 0xc1, 0xa0, 0xa9, 0x92, 0xdf, 0x55, + 0x60, 0xb1, 0xf0, 0x0e, 0x8a, 0x5a, 0x72, 0x61, 0xf9, 0xec, 0x8b, 0xd1, 0x89, 0xea, 0x5b, 0x52, + 0xf5, 0xd5, 0x7c, 0x7c, 0xd9, 0x76, 0xc9, 0xde, 0x5e, 0xcb, 0xb7, 0x4b, 0x02, 0x3f, 0xe2, 0x76, + 0x49, 0x30, 0x52, 0x46, 0xbe, 0xaf, 0xc0, 0x52, 0xf1, 0x3d, 0x0e, 0xfd, 0x4b, 0xf6, 0x91, 0xb9, + 0x7f, 0x84, 0xf0, 0x84, 0x8d, 0xe7, 0x92, 0x8d, 0xb5, 0x02, 0x42, 0xca, 0xc5, 0xcf, 0x15, 0x40, + 0xd9, 0xef, 0x05, 0x6c, 0x55, 0xf9, 0x57, 0xae, 0xf8, 0xa0, 0x53, 0x1f, 0xae, 0xaa, 0x82, 0xcf, + 0x0b, 0xcd, 0x93, 0x2b, 0x97, 0x28, 0x9c, 0x81, 0x96, 0x61, 0x3a, 0xfc, 0x44, 0x11, 0x7f, 0xf2, + 0x99, 0x12, 0x81, 0x76, 0xa7, 0xb1, 0x01, 0x63, 0x0c, 0x8a, 0xa6, 0x61, 0xfc, 0xf3, 0x03, 0x75, + 0xef, 0x64, 0xe6, 0x6f, 0xa8, 0x0e, 0xf0, 0x5e, 0x3d, 0x3c, 0x10, 0x7a, 0x33, 0x95, 0xc7, 0x5f, + 0x43, 0x4d, 0xfa, 0x80, 0x82, 0x30, 0xcc, 0xee, 0x1e, 0x1e, 0x7c, 0xb1, 0xa7, 0x9c, 0x68, 0x87, + 0x47, 0x27, 0xed, 0xc3, 0x03, 0x2d, 0xa2, 0x2e, 0xc2, 0x5c, 0x2a, 0xf3, 0x66, 0x47, 0xdd, 0xdb, + 0x7e, 0x31, 0x53, 0x41, 0x0b, 0x70, 0x37, 0x95, 0x7a, 0xfb, 0xb1, 0x7d, 0x34, 0x73, 0xe3, 0xcd, + 0xeb, 0x8f, 0xff, 0xee, 0x5a, 0xfe, 0x59, 0x60, 0x34, 0x4d, 0xa7, 0xdf, 0x32, 0x74, 0xdf, 0x3c, + 0x33, 0x1d, 0xcf, 0x6d, 0xb9, 0xbd, 0xa0, 0x6f, 0x10, 0xef, 0xa9, 0xb0, 0x4a, 0x5b, 0x46, 0x60, + 0xf5, 0x3a, 0xad, 0xae, 0xd3, 0x12, 0x6f, 0xde, 0x62, 0x6f, 0x6e, 0x4c, 0xf0, 0x87, 0xe7, 0x7f, + 0x06, 0x00, 0x00, 0xff, 0xff, 0x8f, 0x84, 0x9b, 0xda, 0xa7, 0x16, 0x00, 0x00, } diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_write.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_write.pb.go index cccbe114..704842a8 100644 --- a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_write.pb.go +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/opts/ps_opts_write.pb.go @@ -129,10 +129,12 @@ type WriteOptions struct { // @gotags: kong:"cmd,help='Redis Streams'" RedisStreams *WriteGroupRedisStreamsOptions `protobuf:"bytes,116,opt,name=redis_streams,json=redisStreams,proto3" json:"redis_streams,omitempty" kong:"cmd,help='Redis Streams'"` // @gotags: kong:"cmd,help='NATS JetStream'" - NatsJetstream *WriteGroupNatsJetstreamOptions `protobuf:"bytes,117,opt,name=nats_jetstream,json=natsJetstream,proto3" json:"nats_jetstream,omitempty" kong:"cmd,help='NATS JetStream'"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + NatsJetstream *WriteGroupNatsJetstreamOptions `protobuf:"bytes,117,opt,name=nats_jetstream,json=natsJetstream,proto3" json:"nats_jetstream,omitempty" kong:"cmd,help='NATS JetStream'"` + // @gotags: kong:"cmd,help='AWS Kinesis Streams'" + AwsKinesis *WriteGroupAWSKinesisOptions `protobuf:"bytes,118,opt,name=aws_kinesis,json=awsKinesis,proto3" json:"aws_kinesis,omitempty" kong:"cmd,help='AWS Kinesis Streams'"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *WriteOptions) Reset() { *m = WriteOptions{} } @@ -314,6 +316,13 @@ func (m *WriteOptions) GetNatsJetstream() *WriteGroupNatsJetstreamOptions { return nil } +func (m *WriteOptions) GetAwsKinesis() *WriteGroupAWSKinesisOptions { + if m != nil { + return m.AwsKinesis + } + return nil +} + type WriteGroupKafkaOptions struct { // @gotags: kong:"embed" XConn *args.KafkaConn `protobuf:"bytes,1,opt,name=_conn,json=Conn,proto3" json:"_conn,omitempty" kong:"embed"` @@ -1196,6 +1205,55 @@ func (m *WriteGroupKubeMQQueueOptions) GetArgs() *args.KubeMQQueueWriteArgs { return nil } +type WriteGroupAWSKinesisOptions struct { + // @gotags: kong:"embed" + XConn *args.AWSKinesisConn `protobuf:"bytes,1,opt,name=_conn,json=Conn,proto3" json:"_conn,omitempty" kong:"embed"` + // @gotags: kong:"embed" + Args *args.AWSKinesisWriteArgs `protobuf:"bytes,2,opt,name=args,proto3" json:"args,omitempty" kong:"embed"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WriteGroupAWSKinesisOptions) Reset() { *m = WriteGroupAWSKinesisOptions{} } +func (m *WriteGroupAWSKinesisOptions) String() string { return proto.CompactTextString(m) } +func (*WriteGroupAWSKinesisOptions) ProtoMessage() {} +func (*WriteGroupAWSKinesisOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_c48ba9642d1e9ac6, []int{20} +} + +func (m *WriteGroupAWSKinesisOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WriteGroupAWSKinesisOptions.Unmarshal(m, b) +} +func (m *WriteGroupAWSKinesisOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WriteGroupAWSKinesisOptions.Marshal(b, m, deterministic) +} +func (m *WriteGroupAWSKinesisOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_WriteGroupAWSKinesisOptions.Merge(m, src) +} +func (m *WriteGroupAWSKinesisOptions) XXX_Size() int { + return xxx_messageInfo_WriteGroupAWSKinesisOptions.Size(m) +} +func (m *WriteGroupAWSKinesisOptions) XXX_DiscardUnknown() { + xxx_messageInfo_WriteGroupAWSKinesisOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_WriteGroupAWSKinesisOptions proto.InternalMessageInfo + +func (m *WriteGroupAWSKinesisOptions) GetXConn() *args.AWSKinesisConn { + if m != nil { + return m.XConn + } + return nil +} + +func (m *WriteGroupAWSKinesisOptions) GetArgs() *args.AWSKinesisWriteArgs { + if m != nil { + return m.Args + } + return nil +} + func init() { proto.RegisterType((*WriteCLIOptions)(nil), "protos.opts.WriteCLIOptions") proto.RegisterType((*WriteOptions)(nil), "protos.opts.WriteOptions") @@ -1217,88 +1275,93 @@ func init() { proto.RegisterType((*WriteGroupMQTTOptions)(nil), "protos.opts.WriteGroupMQTTOptions") proto.RegisterType((*WriteGroupGCPPubSubOptions)(nil), "protos.opts.WriteGroupGCPPubSubOptions") proto.RegisterType((*WriteGroupKubeMQQueueOptions)(nil), "protos.opts.WriteGroupKubeMQQueueOptions") + proto.RegisterType((*WriteGroupAWSKinesisOptions)(nil), "protos.opts.WriteGroupAWSKinesisOptions") } func init() { proto.RegisterFile("opts/ps_opts_write.proto", fileDescriptor_c48ba9642d1e9ac6) } var fileDescriptor_c48ba9642d1e9ac6 = []byte{ - // 1241 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xdf, 0x4f, 0xdb, 0x46, - 0x1c, 0x57, 0x46, 0x4b, 0xcb, 0x05, 0xda, 0xed, 0xd6, 0xc2, 0x41, 0xf9, 0x11, 0x42, 0xb7, 0xd1, - 0x76, 0x24, 0x1b, 0xa8, 0x9d, 0xd0, 0x36, 0x4d, 0x80, 0x68, 0xd7, 0xae, 0x50, 0xb0, 0x2b, 0x55, - 0xdb, 0x8b, 0x65, 0x3b, 0x47, 0x30, 0x24, 0xb6, 0xe3, 0xb3, 0x41, 0xdd, 0xcb, 0xa6, 0x3d, 0x4d, - 0x9a, 0xb4, 0xa7, 0xfd, 0x91, 0x7b, 0xdb, 0xbf, 0x30, 0xdd, 0x9d, 0xcf, 0xf1, 0xd7, 0xb1, 0x2f, - 0xe9, 0x0b, 0xc1, 0xf7, 0xfd, 0xfc, 0xf2, 0xdd, 0x7d, 0xef, 0x8c, 0x48, 0x10, 0xc6, 0xac, 0x1d, - 0x32, 0x8b, 0xff, 0x5a, 0xd7, 0x91, 0x17, 0xd3, 0x56, 0x18, 0x05, 0x71, 0x80, 0xeb, 0xe2, 0x87, - 0xb5, 0x78, 0x61, 0x69, 0x25, 0xa2, 0x6e, 0x10, 0x75, 0x04, 0x32, 0xfd, 0xd7, 0x72, 0x6c, 0x96, - 0x62, 0x97, 0x1e, 0xd8, 0x51, 0x57, 0xd4, 0xf8, 0xaf, 0x65, 0xbb, 0xb1, 0x77, 0x45, 0xfb, 0x83, - 0xb4, 0xf8, 0x10, 0x16, 0x7f, 0x4d, 0x22, 0x6a, 0x31, 0x1a, 0x5d, 0x79, 0x2e, 0xb5, 0x9c, 0x84, - 0xa5, 0xa8, 0x66, 0x09, 0x8a, 0x5e, 0x51, 0x3f, 0xb6, 0xce, 0x13, 0x27, 0xc5, 0x2c, 0x41, 0xcc, - 0x35, 0xb3, 0x98, 0xcf, 0xaa, 0x6b, 0x03, 0x55, 0x5b, 0x01, 0xb5, 0xae, 0x1b, 0x5a, 0x61, 0xe2, - 0xb0, 0x4c, 0x96, 0x80, 0xf2, 0xa5, 0x7d, 0x76, 0x69, 0xa7, 0x95, 0x35, 0x58, 0x49, 0x1c, 0xda, - 0x1f, 0x58, 0x83, 0x84, 0x26, 0xea, 0xc5, 0x17, 0x00, 0xa0, 0x3f, 0x88, 0xe3, 0xd2, 0x82, 0x6f, - 0xc7, 0x2a, 0xcb, 0xfa, 0x48, 0xc1, 0x62, 0x71, 0x44, 0xed, 0xbe, 0xe7, 0x77, 0xab, 0x21, 0x17, - 0x34, 0x96, 0xa8, 0x14, 0x32, 0x0f, 0x21, 0x4c, 0xcd, 0xf5, 0x22, 0x18, 0x0f, 0x93, 0x1e, 0xb3, - 0xa3, 0xd2, 0x52, 0x64, 0x3b, 0x8e, 0x17, 0x97, 0x1a, 0xca, 0x52, 0x9a, 0x8a, 0x95, 0xce, 0x44, - 0x44, 0x3b, 0x1e, 0x83, 0x93, 0xd8, 0x28, 0x01, 0x40, 0x89, 0x26, 0xf5, 0xdd, 0xa0, 0xe3, 0xf9, - 0x5d, 0x8e, 0x52, 0xff, 0xf3, 0x7d, 0xe7, 0x05, 0x6a, 0x15, 0x9b, 0xbf, 0xd7, 0xd0, 0xdd, 0x77, - 0x7c, 0x13, 0x1e, 0xbc, 0x7e, 0xf9, 0x46, 0x56, 0xf0, 0x0a, 0x42, 0x9e, 0x1f, 0x26, 0xb1, 0x75, - 0xe6, 0xf5, 0x28, 0xa9, 0x35, 0x6a, 0x9b, 0x33, 0xc6, 0x8c, 0x18, 0x79, 0xee, 0xf5, 0x28, 0xde, - 0x42, 0x9f, 0xca, 0xb2, 0xcd, 0xac, 0x0b, 0x16, 0xf8, 0x96, 0x1d, 0x45, 0xf6, 0x7b, 0xf2, 0x51, - 0xa3, 0xb6, 0x79, 0xdb, 0xf8, 0x58, 0x94, 0xf6, 0xd8, 0x2b, 0x16, 0xf8, 0x7b, 0x7c, 0x1c, 0xaf, - 0xa1, 0xba, 0x84, 0xb3, 0xb8, 0xe3, 0xf9, 0x64, 0xaa, 0x31, 0xb5, 0x39, 0x63, 0x48, 0x03, 0x93, - 0x8f, 0x34, 0xff, 0xab, 0xa3, 0x59, 0x11, 0x41, 0xf9, 0x6f, 0xa0, 0x39, 0x37, 0xf0, 0x7d, 0xea, - 0xf2, 0x47, 0xcb, 0xeb, 0xa4, 0x11, 0x66, 0x87, 0x83, 0x2f, 0x3b, 0x78, 0x07, 0x4d, 0xcb, 0xbe, - 0x10, 0xc6, 0xf5, 0xed, 0x07, 0xad, 0xb4, 0x7d, 0xd2, 0x6e, 0x69, 0x09, 0x49, 0x43, 0x3c, 0x18, - 0x29, 0x14, 0x1f, 0xa2, 0x3b, 0x62, 0x1e, 0xa8, 0x9a, 0x05, 0x32, 0x25, 0xc8, 0xab, 0x8a, 0xac, - 0x66, 0xa9, 0x75, 0x28, 0x60, 0x69, 0x22, 0x63, 0x8e, 0xe6, 0x1f, 0xf1, 0x0f, 0x68, 0xd6, 0x72, - 0x7b, 0x5e, 0x26, 0xf2, 0xef, 0x2d, 0xa1, 0xb2, 0xdc, 0xca, 0x75, 0x70, 0xab, 0x30, 0xab, 0x06, - 0x3a, 0xe8, 0x79, 0x4a, 0x60, 0x17, 0xdd, 0x14, 0xbb, 0x9e, 0x74, 0x04, 0x71, 0x63, 0x94, 0xf8, - 0x22, 0x0a, 0x92, 0xf0, 0x27, 0x8e, 0x51, 0x7c, 0xc9, 0xc0, 0xfb, 0xe8, 0xb6, 0x6a, 0x77, 0x42, - 0x05, 0xfb, 0xf3, 0x0a, 0xf6, 0x9e, 0x80, 0x1d, 0x9d, 0x2a, 0x81, 0x8c, 0x87, 0xbf, 0x47, 0xb7, - 0xd2, 0x7e, 0x25, 0x67, 0x42, 0xe2, 0x61, 0x95, 0xc4, 0x3b, 0xd3, 0x3c, 0x35, 0x95, 0xc0, 0xb4, - 0x7d, 0xcd, 0xcc, 0x01, 0xcb, 0xe8, 0x3e, 0x23, 0xdd, 0xb1, 0xf4, 0x63, 0x48, 0xf7, 0x19, 0x7e, - 0x86, 0x6e, 0xf0, 0x16, 0x23, 0xe7, 0x82, 0xdb, 0xac, 0xe0, 0x1e, 0xdb, 0x31, 0x53, 0x4c, 0x81, - 0xc7, 0x06, 0xba, 0x03, 0xbb, 0x97, 0x78, 0x42, 0xe1, 0x89, 0x46, 0xc1, 0x54, 0xd8, 0x6c, 0x25, - 0xfd, 0xfc, 0x28, 0xde, 0x41, 0x53, 0x3e, 0x1b, 0x90, 0x0b, 0x21, 0xb4, 0x5e, 0x25, 0x64, 0x66, - 0x73, 0xc8, 0xd1, 0xf8, 0x3b, 0x34, 0x2d, 0x1b, 0x9d, 0x5c, 0x6a, 0x5f, 0xff, 0x44, 0x80, 0xb2, - 0xd7, 0x97, 0x1c, 0xce, 0x96, 0x0d, 0x4f, 0x7a, 0x5a, 0xb6, 0x21, 0x40, 0x19, 0x5b, 0x72, 0xf8, - 0x24, 0xc0, 0xe3, 0x82, 0xf4, 0xb5, 0x93, 0x20, 0x55, 0xe4, 0x0b, 0x67, 0xf3, 0x39, 0x17, 0xe5, - 0x47, 0xf9, 0x82, 0xf0, 0x83, 0x94, 0xf8, 0xda, 0x05, 0x39, 0x3a, 0x7d, 0xfb, 0x36, 0x5b, 0x10, - 0x8e, 0xc7, 0x3f, 0xa3, 0x4f, 0x46, 0x2e, 0x17, 0x12, 0x08, 0x91, 0xad, 0xaa, 0x1d, 0xc1, 0xf1, - 0xa6, 0x84, 0xef, 0x27, 0x59, 0xa0, 0xbb, 0x36, 0x1c, 0xc7, 0x26, 0xba, 0x5b, 0xb8, 0x91, 0x48, - 0xa8, 0x7d, 0x4f, 0x21, 0x7c, 0xc8, 0xc1, 0x3f, 0x26, 0x4e, 0xf6, 0x9e, 0x76, 0x7e, 0x14, 0x3f, - 0x47, 0x68, 0x78, 0x15, 0x91, 0x81, 0xd0, 0xfb, 0xa2, 0x42, 0xef, 0xc5, 0xc1, 0xc9, 0x49, 0xe2, - 0x98, 0x43, 0xad, 0x99, 0xae, 0x1b, 0x9e, 0x08, 0x26, 0x7e, 0x8d, 0x66, 0xf3, 0x37, 0x13, 0x89, - 0x84, 0xd2, 0xa3, 0xaa, 0x26, 0x4e, 0x1c, 0x7a, 0x74, 0x7a, 0xca, 0x91, 0x4a, 0xab, 0x2e, 0xe9, - 0x62, 0x8c, 0xab, 0xe5, 0x4f, 0x77, 0xc2, 0xb4, 0x6a, 0x06, 0x87, 0xc2, 0x64, 0xf5, 0x28, 0x1d, - 0xe3, 0xd9, 0xde, 0xa0, 0x39, 0x70, 0x15, 0x90, 0x58, 0xc8, 0x3d, 0xd6, 0xc9, 0x15, 0x76, 0x87, - 0x8c, 0xa3, 0x36, 0x87, 0xea, 0xba, 0xec, 0x42, 0x24, 0xc9, 0xd8, 0xae, 0x7b, 0xa5, 0xb0, 0xa0, - 0xeb, 0xb2, 0xd1, 0xe6, 0x15, 0x9a, 0x2f, 0x3f, 0xe4, 0xf0, 0x13, 0x74, 0xd3, 0xe2, 0xc7, 0xbc, - 0x38, 0xf2, 0xeb, 0xdb, 0xf3, 0xca, 0x84, 0xdf, 0x71, 0x2d, 0x81, 0x3c, 0x08, 0x7c, 0xdf, 0xb8, - 0xc1, 0xff, 0xe2, 0x36, 0xba, 0xc1, 0xc7, 0x8b, 0x17, 0xc0, 0x10, 0x2b, 0x4c, 0xf6, 0xa2, 0x2e, - 0x33, 0x04, 0xb0, 0xf9, 0x1b, 0x5a, 0xac, 0x3c, 0x1e, 0x71, 0x0b, 0x5a, 0x2f, 0x02, 0x39, 0x05, - 0xce, 0xb9, 0x6f, 0x03, 0xf7, 0xd5, 0x52, 0x78, 0x31, 0xc0, 0x7b, 0xb4, 0x50, 0x71, 0xb8, 0xe2, - 0x2f, 0xa1, 0xfd, 0x02, 0xd4, 0x13, 0xd0, 0x9c, 0xf9, 0x57, 0xc0, 0x7c, 0xb9, 0x04, 0x3c, 0xd6, - 0xfa, 0x78, 0x72, 0xeb, 0xe3, 0x0f, 0xb1, 0x3e, 0x1e, 0xb1, 0x66, 0xe8, 0x7e, 0xe9, 0xb9, 0x8e, - 0x1f, 0x43, 0xe3, 0xfb, 0x40, 0x8b, 0x03, 0x73, 0xb6, 0x2d, 0x60, 0xbb, 0x34, 0x02, 0x2d, 0x9a, - 0xfe, 0x5d, 0x43, 0xab, 0xfa, 0x5d, 0x89, 0x77, 0xa0, 0xfd, 0xea, 0x88, 0x66, 0xc6, 0xc8, 0xe5, - 0xf8, 0x06, 0xe4, 0xd8, 0xa8, 0xe6, 0x8c, 0x0f, 0x54, 0xbc, 0x9c, 0xc6, 0x07, 0xca, 0x18, 0x1f, - 0x10, 0x28, 0xe3, 0x14, 0x03, 0x85, 0xe8, 0x5e, 0xd9, 0x1d, 0x87, 0x1f, 0xc1, 0x14, 0xf7, 0xa0, - 0xa2, 0x99, 0xef, 0x81, 0x2d, 0xe0, 0xbd, 0x58, 0x44, 0x6a, 0xf7, 0x20, 0xb8, 0x1d, 0xf5, 0x7b, - 0x50, 0x42, 0x27, 0xdc, 0x83, 0x12, 0xac, 0xb5, 0x06, 0x57, 0xab, 0xde, 0x5a, 0x42, 0x27, 0xb4, - 0x96, 0x60, 0xfd, 0xc2, 0x97, 0x5d, 0xc8, 0xfa, 0x85, 0x07, 0x8c, 0x09, 0x17, 0x1e, 0x70, 0x8a, - 0x81, 0xfe, 0xac, 0xa1, 0x65, 0xdd, 0x8d, 0x82, 0xbf, 0x86, 0x71, 0x0a, 0x2f, 0x39, 0xc4, 0xe7, - 0xc2, 0x3c, 0x05, 0x61, 0xd6, 0xab, 0x18, 0xc5, 0x28, 0x7f, 0xd5, 0xd0, 0x8a, 0xf6, 0x36, 0xc2, - 0xdb, 0x30, 0xcb, 0xca, 0xa8, 0xf2, 0xe8, 0xcc, 0x3c, 0x03, 0x61, 0x9a, 0x95, 0x14, 0xfd, 0x4a, - 0x95, 0x7d, 0x52, 0xe8, 0x57, 0x0a, 0x30, 0x26, 0x5c, 0x29, 0xc0, 0x29, 0x06, 0xfa, 0xa7, 0x86, - 0x1a, 0xe3, 0x3e, 0x9e, 0xf0, 0x53, 0x18, 0xa9, 0x31, 0x2a, 0x3f, 0xe4, 0xe4, 0x42, 0xed, 0x82, - 0x50, 0x9f, 0xe9, 0x58, 0xda, 0x03, 0x3d, 0xf7, 0x5d, 0xa8, 0x3f, 0xd0, 0x39, 0x70, 0xc2, 0x03, - 0x9d, 0x43, 0x8b, 0xa6, 0x7f, 0xd4, 0xd0, 0x52, 0xf5, 0xf7, 0x19, 0x6e, 0x43, 0x6b, 0xa8, 0x97, - 0xa1, 0x73, 0xfe, 0x3b, 0xc0, 0x7f, 0xad, 0x1c, 0xaf, 0x6f, 0x9d, 0xd1, 0x4f, 0x3b, 0x7d, 0xeb, - 0xe4, 0xf0, 0x13, 0xb6, 0x4e, 0x8e, 0x51, 0x88, 0xb2, 0xff, 0xed, 0x2f, 0xbb, 0x5d, 0x2f, 0x3e, - 0x4f, 0x9c, 0x96, 0x1b, 0xf4, 0xdb, 0x8e, 0x1d, 0xbb, 0xe7, 0x6e, 0x10, 0x85, 0xed, 0xb0, 0x97, - 0xf4, 0x1d, 0x1a, 0x6d, 0x31, 0xf7, 0x9c, 0xf6, 0x6d, 0xd6, 0x76, 0x12, 0xaf, 0xd7, 0x69, 0x77, - 0x83, 0xb6, 0xd4, 0x6d, 0xf3, 0xef, 0x35, 0x67, 0x5a, 0x3c, 0xec, 0xfc, 0x1f, 0x00, 0x00, 0xff, - 0xff, 0x9a, 0xe4, 0x2a, 0x32, 0x8e, 0x12, 0x00, 0x00, + // 1300 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x5d, 0x4f, 0xdc, 0x46, + 0x14, 0xd5, 0x96, 0x84, 0x84, 0x59, 0x48, 0xda, 0x69, 0x02, 0xc3, 0xf7, 0xb2, 0xa4, 0x2d, 0x49, + 0xca, 0x6e, 0x0a, 0x4d, 0x2a, 0xd4, 0x56, 0x15, 0x20, 0x92, 0x92, 0x04, 0x02, 0xde, 0x48, 0x51, + 0xfb, 0x62, 0xd9, 0xde, 0x61, 0x31, 0xec, 0xda, 0x5e, 0x8f, 0x0d, 0x4a, 0x5f, 0x5a, 0x55, 0xaa, + 0x54, 0xa9, 0x52, 0x9f, 0xfa, 0x6b, 0xfa, 0x8b, 0xfa, 0x33, 0xaa, 0x99, 0xf1, 0x78, 0x7d, 0xbd, + 0xf6, 0xec, 0xe6, 0x85, 0xc5, 0xf7, 0x9e, 0x73, 0xee, 0xf1, 0xcc, 0xdc, 0xb9, 0x46, 0xc4, 0x0f, + 0x22, 0xd6, 0x0c, 0x98, 0xc9, 0x7f, 0xcd, 0xeb, 0xd0, 0x8d, 0x68, 0x23, 0x08, 0xfd, 0xc8, 0xc7, + 0x55, 0xf1, 0xc3, 0x1a, 0x3c, 0xb1, 0xb0, 0x1c, 0x52, 0xc7, 0x0f, 0xdb, 0x02, 0x99, 0xfc, 0x6b, + 0xda, 0x16, 0x4b, 0xb0, 0x0b, 0x8b, 0x56, 0xd8, 0x11, 0x39, 0xfe, 0x6b, 0x5a, 0x4e, 0xe4, 0x5e, + 0xd1, 0x5e, 0x3f, 0x49, 0x3e, 0x80, 0xc9, 0x5f, 0xe2, 0x90, 0x9a, 0x8c, 0x86, 0x57, 0xae, 0x43, + 0x4d, 0x3b, 0x66, 0x09, 0xaa, 0x5e, 0x80, 0xa2, 0x57, 0xd4, 0x8b, 0xcc, 0xf3, 0xd8, 0x4e, 0x30, + 0x2b, 0x10, 0x73, 0xcd, 0xcc, 0x4b, 0xd7, 0xa3, 0xcc, 0x55, 0x1a, 0x0b, 0x43, 0x79, 0xe6, 0x69, + 0x72, 0x7d, 0x95, 0x5b, 0x06, 0xb9, 0x8e, 0x13, 0x98, 0x41, 0x6c, 0xb3, 0xb4, 0x2c, 0x01, 0xe9, + 0x4b, 0xeb, 0xec, 0xd2, 0x4a, 0x32, 0xab, 0x30, 0x13, 0xdb, 0xb4, 0xd7, 0x37, 0xfb, 0x31, 0x8d, + 0xd5, 0xc2, 0xcc, 0x01, 0x40, 0xaf, 0x1f, 0x45, 0x85, 0x09, 0xcf, 0x8a, 0x94, 0x97, 0xb5, 0xa1, + 0x84, 0xc9, 0xa2, 0x90, 0x5a, 0x3d, 0xd7, 0xeb, 0x94, 0x43, 0x2e, 0x68, 0x24, 0x51, 0x09, 0x64, + 0x16, 0x42, 0x98, 0xda, 0x8b, 0x79, 0x10, 0x0f, 0xe2, 0x2e, 0xb3, 0xc2, 0xc2, 0x54, 0x68, 0xd9, + 0xb6, 0x1b, 0x15, 0x16, 0x94, 0xa9, 0xc4, 0x15, 0x2b, 0x5c, 0x89, 0x90, 0xb6, 0x5d, 0x06, 0x17, + 0xb1, 0x56, 0x00, 0x80, 0x12, 0x75, 0xea, 0x39, 0x7e, 0xdb, 0xf5, 0x3a, 0x1c, 0xa5, 0xfe, 0xe7, + 0xe7, 0xd2, 0xf5, 0xd5, 0x2e, 0xd6, 0x7f, 0xab, 0xa0, 0xbb, 0xef, 0xf8, 0x21, 0xdd, 0x7f, 0x7d, + 0xf8, 0x46, 0x66, 0xf0, 0x32, 0x42, 0xae, 0x17, 0xc4, 0x91, 0x79, 0xe6, 0x76, 0x29, 0xa9, 0xd4, + 0x2a, 0x1b, 0x53, 0xc6, 0x94, 0x88, 0x3c, 0x77, 0xbb, 0x14, 0x6f, 0xa2, 0x4f, 0x65, 0xda, 0x62, + 0xe6, 0x05, 0xf3, 0x3d, 0xd3, 0x0a, 0x43, 0xeb, 0x3d, 0xf9, 0xa8, 0x56, 0xd9, 0xb8, 0x6d, 0x7c, + 0x2c, 0x52, 0xbb, 0xec, 0x25, 0xf3, 0xbd, 0x5d, 0x1e, 0xc7, 0xab, 0xa8, 0x2a, 0xe1, 0x2c, 0x6a, + 0xbb, 0x1e, 0x99, 0xa8, 0x4d, 0x6c, 0x4c, 0x19, 0xb2, 0x40, 0x8b, 0x47, 0xea, 0xff, 0x4e, 0xa3, + 0x69, 0x61, 0x41, 0xd5, 0x5f, 0x47, 0x33, 0x8e, 0xef, 0x79, 0xd4, 0xe1, 0x8f, 0xa6, 0xdb, 0x4e, + 0x2c, 0x4c, 0x0f, 0x82, 0x87, 0x6d, 0xbc, 0x8d, 0x26, 0x65, 0xdf, 0x88, 0xc2, 0xd5, 0xad, 0xc5, + 0x46, 0xd2, 0x5e, 0x49, 0x37, 0x35, 0x84, 0xa4, 0x21, 0x1e, 0x8c, 0x04, 0x8a, 0x0f, 0xd0, 0x1d, + 0xb1, 0x0e, 0x54, 0xad, 0x02, 0x99, 0x10, 0xe4, 0x15, 0x45, 0x56, 0xab, 0xd4, 0x38, 0x10, 0xb0, + 0xc4, 0x91, 0x31, 0x43, 0xb3, 0x8f, 0xf8, 0x07, 0x34, 0x6d, 0x3a, 0x5d, 0x37, 0x15, 0xf9, 0xef, + 0x96, 0x50, 0x59, 0x6a, 0x64, 0x3a, 0xbc, 0x91, 0x5b, 0x55, 0x03, 0xed, 0x77, 0x5d, 0x25, 0xb0, + 0x83, 0x6e, 0x8a, 0x53, 0x4f, 0xda, 0x82, 0xb8, 0x3e, 0x4c, 0x7c, 0x11, 0xfa, 0x71, 0xf0, 0x8a, + 0x63, 0x14, 0x5f, 0x32, 0xf0, 0x1e, 0xba, 0xad, 0xae, 0x03, 0x42, 0x05, 0xfb, 0xf3, 0x12, 0xf6, + 0xae, 0x80, 0x1d, 0x9d, 0x2a, 0x81, 0x94, 0x87, 0xbf, 0x47, 0xb7, 0x92, 0x7e, 0x25, 0x67, 0x42, + 0xe2, 0x41, 0x99, 0xc4, 0xbb, 0x56, 0xeb, 0xb4, 0xa5, 0x04, 0x26, 0xad, 0x6b, 0xd6, 0xea, 0xb3, + 0x94, 0xee, 0x31, 0xd2, 0x19, 0x49, 0x3f, 0x86, 0x74, 0x8f, 0xe1, 0x67, 0xe8, 0x06, 0x6f, 0x31, + 0x72, 0x2e, 0xb8, 0xf5, 0x12, 0xee, 0xb1, 0x15, 0x31, 0xc5, 0x14, 0x78, 0x6c, 0xa0, 0x3b, 0xb0, + 0x7b, 0x89, 0x2b, 0x14, 0x1e, 0x6b, 0x14, 0x5a, 0x0a, 0x9b, 0xee, 0xa4, 0x97, 0x8d, 0xe2, 0x6d, + 0x34, 0xe1, 0xb1, 0x3e, 0xb9, 0x10, 0x42, 0x6b, 0x65, 0x42, 0xad, 0x74, 0x0d, 0x39, 0x1a, 0x7f, + 0x87, 0x26, 0x65, 0xa3, 0x93, 0x4b, 0xed, 0xeb, 0x9f, 0x08, 0x50, 0xfa, 0xfa, 0x92, 0xc3, 0xd9, + 0xb2, 0xe1, 0x49, 0x57, 0xcb, 0x36, 0x04, 0x28, 0x65, 0x4b, 0x0e, 0x5f, 0x04, 0x78, 0x5d, 0x90, + 0x9e, 0x76, 0x11, 0xa4, 0x8a, 0x7c, 0xe1, 0x74, 0x3d, 0x67, 0xc2, 0x6c, 0x94, 0x6f, 0x08, 0xbf, + 0x48, 0x89, 0xa7, 0xdd, 0x90, 0xa3, 0xd3, 0xb7, 0x6f, 0xd3, 0x0d, 0xe1, 0x78, 0xfc, 0x13, 0xfa, + 0x64, 0x68, 0xf8, 0x10, 0x5f, 0x88, 0x6c, 0x96, 0x9d, 0x08, 0x8e, 0x6f, 0x49, 0xf8, 0x5e, 0x9c, + 0x1a, 0xba, 0x6b, 0xc1, 0x38, 0x6e, 0xa1, 0xbb, 0xb9, 0x89, 0x45, 0x02, 0xed, 0x7b, 0x0a, 0xe1, + 0x03, 0x0e, 0xfe, 0x31, 0xb6, 0xd3, 0xf7, 0xb4, 0xb2, 0x51, 0xfc, 0x1c, 0xa1, 0xc1, 0x28, 0x22, + 0x7d, 0xa1, 0xf7, 0x45, 0x89, 0xde, 0x8b, 0xfd, 0x93, 0x93, 0xd8, 0x6e, 0x0d, 0xb4, 0xa6, 0x3a, + 0x4e, 0x70, 0x22, 0x98, 0xf8, 0x35, 0x9a, 0xce, 0x4e, 0x26, 0x12, 0x0a, 0xa5, 0x87, 0x65, 0x4d, + 0x1c, 0xdb, 0xf4, 0xe8, 0xf4, 0x94, 0x23, 0x95, 0x56, 0x55, 0xd2, 0x45, 0x8c, 0xab, 0x65, 0x6f, + 0x77, 0xc2, 0xb4, 0x6a, 0x06, 0x87, 0x42, 0x67, 0xd5, 0x30, 0x89, 0x71, 0x6f, 0x6f, 0xd0, 0x0c, + 0x18, 0x05, 0x24, 0x12, 0x72, 0x8f, 0x74, 0x72, 0xb9, 0xd3, 0x21, 0xed, 0xa8, 0xc3, 0xa1, 0xba, + 0x2e, 0x1d, 0x88, 0x24, 0x1e, 0xd9, 0x75, 0x2f, 0x15, 0x16, 0x74, 0x5d, 0x1a, 0xc5, 0x87, 0xa8, + 0x9a, 0xf9, 0xd6, 0x20, 0x57, 0x42, 0x70, 0xa3, 0xfc, 0x12, 0x79, 0x25, 0x81, 0xe9, 0x4d, 0x6a, + 0x5d, 0xb3, 0x24, 0x54, 0xbf, 0x42, 0xb3, 0xc5, 0xf7, 0x25, 0x7e, 0x8c, 0x6e, 0x9a, 0x7c, 0x62, + 0x88, 0xe9, 0x51, 0xdd, 0x9a, 0x55, 0xf2, 0x7c, 0x5c, 0x36, 0x04, 0x72, 0xdf, 0xf7, 0x3c, 0xe3, + 0x06, 0xff, 0x8b, 0x9b, 0xe8, 0x06, 0x8f, 0xe7, 0x67, 0xc9, 0x00, 0x2b, 0x8a, 0xec, 0x86, 0x1d, + 0x66, 0x08, 0x60, 0xfd, 0x57, 0x34, 0x5f, 0x7a, 0xd3, 0xe2, 0x06, 0x2c, 0x3d, 0x0f, 0xe4, 0x14, + 0x38, 0x53, 0x7d, 0x0b, 0x54, 0x5f, 0x29, 0x84, 0xe7, 0x0d, 0xbc, 0x47, 0x73, 0x25, 0xf7, 0x34, + 0xfe, 0x12, 0x96, 0x9f, 0x83, 0x7a, 0x02, 0x9a, 0x29, 0xfe, 0x04, 0x14, 0x5f, 0x2a, 0x00, 0x8f, + 0x2c, 0x7d, 0x3c, 0x7e, 0xe9, 0xe3, 0x0f, 0x29, 0x7d, 0x3c, 0x54, 0x9a, 0xa1, 0xfb, 0x85, 0x23, + 0x02, 0x3f, 0x82, 0x85, 0xef, 0x03, 0x2d, 0x0e, 0xcc, 0x94, 0x6d, 0x80, 0xb2, 0x0b, 0x43, 0xd0, + 0x7c, 0xd1, 0xbf, 0x2b, 0x68, 0x45, 0x7f, 0xc0, 0xf1, 0x36, 0x2c, 0xbf, 0x32, 0xa4, 0x99, 0x32, + 0x32, 0x3e, 0xbe, 0x01, 0x3e, 0xd6, 0xcb, 0x39, 0xa3, 0x0d, 0xe5, 0xe7, 0xdc, 0x68, 0x43, 0x29, + 0xe3, 0x03, 0x0c, 0xa5, 0x9c, 0xbc, 0xa1, 0x00, 0xdd, 0x2b, 0x1a, 0x97, 0xf8, 0x21, 0x74, 0x71, + 0x0f, 0x2a, 0xb6, 0xb2, 0x3d, 0xb0, 0x09, 0x6a, 0xcf, 0xe7, 0x91, 0xda, 0x33, 0x08, 0x06, 0xad, + 0xfe, 0x0c, 0x4a, 0xe8, 0x98, 0x67, 0x50, 0x82, 0xb5, 0xa5, 0xc1, 0x94, 0xd6, 0x97, 0x96, 0xd0, + 0x31, 0x4b, 0x4b, 0xb0, 0x7e, 0xe3, 0x8b, 0x66, 0xbb, 0x7e, 0xe3, 0x01, 0x63, 0xcc, 0x8d, 0x07, + 0x9c, 0xbc, 0xa1, 0x3f, 0x2b, 0x68, 0x49, 0x37, 0x9c, 0xf0, 0x57, 0xd0, 0x4e, 0xee, 0x25, 0x07, + 0xf8, 0x8c, 0x99, 0xa7, 0xc0, 0xcc, 0x5a, 0x19, 0x23, 0x6f, 0xe5, 0xaf, 0x0a, 0x5a, 0xd6, 0x0e, + 0x36, 0xbc, 0x05, 0xbd, 0x2c, 0x0f, 0x2b, 0x0f, 0xaf, 0xcc, 0x33, 0x60, 0xa6, 0x5e, 0x4a, 0xd1, + 0xef, 0x54, 0xd1, 0xd7, 0x89, 0x7e, 0xa7, 0x00, 0x63, 0xcc, 0x9d, 0x02, 0x9c, 0xbc, 0xa1, 0x7f, + 0x2a, 0xa8, 0x36, 0xea, 0x3b, 0x0c, 0x3f, 0x85, 0x96, 0x6a, 0xc3, 0xf2, 0x03, 0x4e, 0xc6, 0xd4, + 0x0e, 0x30, 0xf5, 0x99, 0x8e, 0xa5, 0xbd, 0xd0, 0x33, 0x9f, 0x98, 0xfa, 0x0b, 0x9d, 0x03, 0xc7, + 0xbc, 0xd0, 0x39, 0x34, 0x5f, 0xf4, 0xf7, 0x0a, 0x5a, 0x28, 0xff, 0xd4, 0xc3, 0x4d, 0x58, 0x1a, + 0xea, 0xa5, 0xe8, 0x4c, 0xfd, 0x6d, 0x50, 0x7f, 0xb5, 0x18, 0xaf, 0x6f, 0x9d, 0xe1, 0xaf, 0x44, + 0x7d, 0xeb, 0x64, 0xf0, 0x63, 0xb6, 0x4e, 0x86, 0x91, 0xb7, 0xf2, 0x47, 0x05, 0x2d, 0x6a, 0x3e, + 0xb8, 0xf0, 0x13, 0xe8, 0x64, 0x31, 0x3f, 0xa8, 0x13, 0x78, 0xc6, 0xc8, 0xd7, 0xc0, 0x48, 0xad, + 0x84, 0x90, 0xf3, 0xb1, 0xf7, 0xed, 0xcf, 0x3b, 0x1d, 0x37, 0x3a, 0x8f, 0xed, 0x86, 0xe3, 0xf7, + 0x9a, 0xb6, 0x15, 0x39, 0xe7, 0x8e, 0x1f, 0x06, 0xcd, 0xa0, 0x1b, 0xf7, 0x6c, 0x1a, 0x6e, 0x32, + 0xe7, 0x9c, 0xf6, 0x2c, 0xd6, 0xb4, 0x63, 0xb7, 0xdb, 0x6e, 0x76, 0xfc, 0xa6, 0x94, 0x6d, 0xf2, + 0x2f, 0x46, 0x7b, 0x52, 0x3c, 0x6c, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x46, 0x50, 0x67, 0x14, + 0x81, 0x13, 0x00, 0x00, } diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/records/ps_records_aws_kinesis.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/records/ps_records_aws_kinesis.pb.go new file mode 100644 index 00000000..544a81c5 --- /dev/null +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/records/ps_records_aws_kinesis.pb.go @@ -0,0 +1,120 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: records/ps_records_aws_kinesis.proto + +package records + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type AWSKinesis struct { + PartitionKey string `protobuf:"bytes,1,opt,name=partition_key,json=partitionKey,proto3" json:"partition_key,omitempty"` + SequenceNumber string `protobuf:"bytes,2,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"` + EncryptionType string `protobuf:"bytes,3,opt,name=encryption_type,json=encryptionType,proto3" json:"encryption_type,omitempty"` + ShardId string `protobuf:"bytes,4,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"` + Value []byte `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AWSKinesis) Reset() { *m = AWSKinesis{} } +func (m *AWSKinesis) String() string { return proto.CompactTextString(m) } +func (*AWSKinesis) ProtoMessage() {} +func (*AWSKinesis) Descriptor() ([]byte, []int) { + return fileDescriptor_2175e9a738d05407, []int{0} +} + +func (m *AWSKinesis) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AWSKinesis.Unmarshal(m, b) +} +func (m *AWSKinesis) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AWSKinesis.Marshal(b, m, deterministic) +} +func (m *AWSKinesis) XXX_Merge(src proto.Message) { + xxx_messageInfo_AWSKinesis.Merge(m, src) +} +func (m *AWSKinesis) XXX_Size() int { + return xxx_messageInfo_AWSKinesis.Size(m) +} +func (m *AWSKinesis) XXX_DiscardUnknown() { + xxx_messageInfo_AWSKinesis.DiscardUnknown(m) +} + +var xxx_messageInfo_AWSKinesis proto.InternalMessageInfo + +func (m *AWSKinesis) GetPartitionKey() string { + if m != nil { + return m.PartitionKey + } + return "" +} + +func (m *AWSKinesis) GetSequenceNumber() string { + if m != nil { + return m.SequenceNumber + } + return "" +} + +func (m *AWSKinesis) GetEncryptionType() string { + if m != nil { + return m.EncryptionType + } + return "" +} + +func (m *AWSKinesis) GetShardId() string { + if m != nil { + return m.ShardId + } + return "" +} + +func (m *AWSKinesis) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func init() { + proto.RegisterType((*AWSKinesis)(nil), "protos.records.AWSKinesis") +} + +func init() { + proto.RegisterFile("records/ps_records_aws_kinesis.proto", fileDescriptor_2175e9a738d05407) +} + +var fileDescriptor_2175e9a738d05407 = []byte{ + // 244 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x8f, 0x4d, 0x4b, 0x03, 0x31, + 0x10, 0x86, 0x59, 0xb5, 0x7e, 0x84, 0x5a, 0x21, 0x78, 0x88, 0xb7, 0xa2, 0x82, 0xbd, 0xd8, 0x1c, + 0xbc, 0x8a, 0xa0, 0x37, 0x29, 0x78, 0xa8, 0x82, 0xe0, 0x25, 0xe4, 0x63, 0xe8, 0x86, 0xee, 0x26, + 0x31, 0x93, 0x28, 0xf9, 0x5f, 0xfe, 0x40, 0x31, 0xbb, 0xea, 0x69, 0xe6, 0x7d, 0x78, 0x98, 0xe1, + 0x25, 0x97, 0x11, 0xb4, 0x8f, 0x06, 0x79, 0x40, 0x31, 0xae, 0x42, 0x7e, 0xa2, 0xd8, 0x5a, 0x07, + 0x68, 0x71, 0x19, 0xa2, 0x4f, 0x9e, 0xce, 0xea, 0xc0, 0xe5, 0x68, 0x9c, 0x7f, 0x35, 0x84, 0xdc, + 0xbf, 0x3e, 0xaf, 0x06, 0x89, 0x5e, 0x90, 0xe3, 0x20, 0x63, 0xb2, 0xc9, 0x7a, 0x27, 0xb6, 0x50, + 0x58, 0x33, 0x6f, 0x16, 0x47, 0xeb, 0xe9, 0x1f, 0x5c, 0x41, 0xa1, 0x57, 0xe4, 0x04, 0xe1, 0x3d, + 0x83, 0xd3, 0x20, 0x5c, 0xee, 0x15, 0x44, 0xb6, 0x53, 0xb5, 0xd9, 0x2f, 0x7e, 0xaa, 0xf4, 0x47, + 0x04, 0xa7, 0x63, 0x09, 0xf5, 0x5c, 0x2a, 0x01, 0xd8, 0xee, 0x20, 0xfe, 0xe3, 0x97, 0x12, 0x80, + 0x9e, 0x91, 0x43, 0x6c, 0x65, 0x34, 0xc2, 0x1a, 0xb6, 0x57, 0x8d, 0x83, 0x9a, 0x1f, 0x0d, 0x3d, + 0x25, 0x93, 0x0f, 0xd9, 0x65, 0x60, 0x93, 0x79, 0xb3, 0x98, 0xae, 0x87, 0xf0, 0x70, 0xf7, 0x76, + 0xbb, 0xb1, 0xa9, 0xcd, 0x6a, 0xa9, 0x7d, 0xcf, 0x95, 0x4c, 0xba, 0xd5, 0x3e, 0x06, 0x1e, 0xba, + 0xfa, 0xf9, 0x1a, 0x75, 0x0b, 0xbd, 0x44, 0xae, 0xb2, 0xed, 0x0c, 0xdf, 0x78, 0x3e, 0xd4, 0xe6, + 0x63, 0x6d, 0xb5, 0x5f, 0xf3, 0xcd, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x74, 0x18, 0xe4, 0xfa, + 0x35, 0x01, 0x00, 0x00, +} diff --git a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/records/ps_records_base.pb.go b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/records/ps_records_base.pb.go index 08723c97..fd6b5977 100644 --- a/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/records/ps_records_base.pb.go +++ b/vendor/github.com/batchcorp/plumber-schemas/build/go/protos/records/ps_records_base.pb.go @@ -62,6 +62,7 @@ type ReadRecord struct { // *ReadRecord_RedisPubsub // *ReadRecord_RedisStreams // *ReadRecord_NatsJetstream + // *ReadRecord_AwsKinesis Record isReadRecord_Record `protobuf_oneof:"Record"` // Original backend message (encoded with gob, ie. *skafka.Message, etc.). // In most cases, you should use the oneof record instead of the raw message. @@ -213,6 +214,10 @@ type ReadRecord_NatsJetstream struct { NatsJetstream *NatsJetstream `protobuf:"bytes,118,opt,name=nats_jetstream,json=natsJetstream,proto3,oneof"` } +type ReadRecord_AwsKinesis struct { + AwsKinesis *AWSKinesis `protobuf:"bytes,119,opt,name=aws_kinesis,json=awsKinesis,proto3,oneof"` +} + func (*ReadRecord_Kafka) isReadRecord_Record() {} func (*ReadRecord_Rabbit) isReadRecord_Record() {} @@ -251,6 +256,8 @@ func (*ReadRecord_RedisStreams) isReadRecord_Record() {} func (*ReadRecord_NatsJetstream) isReadRecord_Record() {} +func (*ReadRecord_AwsKinesis) isReadRecord_Record() {} + func (m *ReadRecord) GetRecord() isReadRecord_Record { if m != nil { return m.Record @@ -391,6 +398,13 @@ func (m *ReadRecord) GetNatsJetstream() *NatsJetstream { return nil } +func (m *ReadRecord) GetAwsKinesis() *AWSKinesis { + if x, ok := m.GetRecord().(*ReadRecord_AwsKinesis); ok { + return x.AwsKinesis + } + return nil +} + func (m *ReadRecord) GetXRaw() []byte { if m != nil { return m.XRaw @@ -427,6 +441,7 @@ func (*ReadRecord) XXX_OneofWrappers() []interface{} { (*ReadRecord_RedisPubsub)(nil), (*ReadRecord_RedisStreams)(nil), (*ReadRecord_NatsJetstream)(nil), + (*ReadRecord_AwsKinesis)(nil), } } @@ -550,67 +565,69 @@ func init() { func init() { proto.RegisterFile("records/ps_records_base.proto", fileDescriptor_79a95b759e1a93f6) } var fileDescriptor_79a95b759e1a93f6 = []byte{ - // 978 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x96, 0xeb, 0x6e, 0x1b, 0x45, - 0x14, 0xc7, 0xbd, 0x71, 0xae, 0xe3, 0x38, 0xc0, 0x34, 0xd0, 0x21, 0x34, 0xc4, 0x04, 0x41, 0x4d, - 0xa5, 0xda, 0x50, 0x2a, 0x84, 0x0a, 0x42, 0x4d, 0x4b, 0xa8, 0x43, 0x15, 0xe4, 0xac, 0x13, 0x55, - 0xe2, 0xcb, 0x6a, 0x76, 0x77, 0xba, 0xd9, 0xda, 0x7b, 0xf1, 0x5c, 0x9c, 0x86, 0x47, 0xe1, 0x59, - 0x78, 0x15, 0xbe, 0xc3, 0x5b, 0xa0, 0xb9, 0xac, 0xbd, 0xf6, 0x8e, 0x8d, 0xfa, 0x29, 0x3b, 0x73, - 0x7e, 0x73, 0xe6, 0x5c, 0xe6, 0xfc, 0x1d, 0x70, 0x48, 0x49, 0x90, 0xd1, 0x90, 0x75, 0x73, 0xe6, - 0x99, 0x4f, 0xcf, 0xc7, 0x8c, 0x74, 0x72, 0x9a, 0xf1, 0x0c, 0xee, 0xa9, 0x3f, 0xac, 0x63, 0x4c, - 0x07, 0x9f, 0x5a, 0xf0, 0x21, 0x7e, 0x3d, 0xc4, 0x9a, 0x3f, 0x38, 0xb2, 0xd8, 0x29, 0xf6, 0xfd, - 0x98, 0x1b, 0xe0, 0x33, 0x0b, 0x80, 0x03, 0x1e, 0x4f, 0x48, 0x32, 0x36, 0x48, 0xcb, 0x86, 0xdc, - 0x30, 0x8f, 0x8d, 0x99, 0x21, 0xda, 0x36, 0xe2, 0x0f, 0x41, 0x89, 0x47, 0x26, 0x24, 0xe5, 0xde, - 0xb5, 0xf0, 0x0d, 0xf9, 0x60, 0x29, 0xc9, 0x08, 0x9d, 0xc4, 0x01, 0xf1, 0x7c, 0x51, 0x78, 0xfd, - 0xdc, 0xc2, 0x46, 0x41, 0xee, 0xe5, 0xc2, 0x67, 0x53, 0x87, 0xb6, 0x04, 0x87, 0xc2, 0x9f, 0x45, - 0x6f, 0xab, 0x50, 0x92, 0xa5, 0x51, 0x66, 0xec, 0xb6, 0x82, 0x27, 0x63, 0xce, 0x57, 0x98, 0x53, - 0xcc, 0x8b, 0x18, 0xef, 0x2f, 0x31, 0x7b, 0x8c, 0x53, 0x82, 0x93, 0x38, 0x8d, 0xfe, 0x0f, 0x7c, - 0x43, 0xb8, 0x66, 0x0d, 0x78, 0xcf, 0x06, 0xb2, 0xf1, 0x8a, 0x76, 0xe5, 0x19, 0xe3, 0x11, 0x25, - 0x6c, 0x45, 0x45, 0x72, 0x31, 0x62, 0x98, 0xae, 0x08, 0x45, 0xbf, 0x09, 0x13, 0x75, 0xe1, 0xe9, - 0x0b, 0x1b, 0x48, 0xc2, 0x98, 0xcd, 0xb7, 0xe0, 0xcb, 0xa5, 0xd8, 0x9c, 0xbb, 0xe3, 0x3f, 0x1b, - 0x00, 0xb8, 0x04, 0x87, 0xae, 0x62, 0xe0, 0x21, 0x00, 0x09, 0x61, 0x0c, 0x47, 0xc4, 0x8b, 0x43, - 0xe4, 0xb4, 0x9c, 0xf6, 0x8e, 0xbb, 0x63, 0x76, 0xce, 0x42, 0xf8, 0x3e, 0xa8, 0xa7, 0x22, 0x41, - 0xf5, 0x96, 0xd3, 0xae, 0xbb, 0xf2, 0x13, 0xfe, 0x0c, 0xb6, 0x13, 0xc2, 0x71, 0x88, 0x39, 0x46, - 0xeb, 0xad, 0x7a, 0xbb, 0xf1, 0xa8, 0xdd, 0x99, 0x1f, 0x87, 0xce, 0xcc, 0x7d, 0xe7, 0xdc, 0xa0, - 0xa7, 0x29, 0xa7, 0xb7, 0xee, 0xf4, 0x24, 0x7c, 0x0c, 0xee, 0x52, 0x12, 0x90, 0x78, 0x42, 0x42, - 0x0f, 0x73, 0x4f, 0xa4, 0xf1, 0x5b, 0x8f, 0x33, 0x4f, 0xf0, 0x00, 0x6d, 0xaa, 0xbb, 0xee, 0x14, - 0xe6, 0x13, 0x7e, 0x95, 0xc6, 0x6f, 0x2f, 0xd9, 0x15, 0x0f, 0x20, 0x02, 0x5b, 0x39, 0xbe, 0x1d, - 0x65, 0x38, 0x44, 0x41, 0xcb, 0x69, 0xef, 0xba, 0xc5, 0x12, 0x3e, 0x04, 0x1b, 0x6a, 0xe0, 0x50, - 0xd8, 0x72, 0xda, 0x8d, 0x47, 0x1f, 0x2e, 0x86, 0xf4, 0x52, 0x1a, 0x7b, 0x35, 0x57, 0x53, 0xf0, - 0x6b, 0xb0, 0xa9, 0x6b, 0x8d, 0x88, 0xe2, 0x3f, 0xaa, 0xa4, 0xa0, 0xac, 0xbd, 0x9a, 0x6b, 0x38, - 0xf8, 0x1d, 0xd8, 0x2e, 0x06, 0x12, 0xbd, 0x56, 0x67, 0xd0, 0xe2, 0x99, 0x13, 0x65, 0x3f, 0xbf, - 0xe8, 0xd5, 0xdc, 0x29, 0x0b, 0xbf, 0x01, 0x5b, 0x66, 0x4a, 0x51, 0x64, 0xbf, 0xea, 0xe4, 0xd5, - 0x60, 0x70, 0x31, 0x90, 0x57, 0xe1, 0x1b, 0x36, 0x18, 0x33, 0xf8, 0x02, 0xbc, 0xb7, 0x30, 0xb6, - 0xe8, 0x5a, 0x1d, 0x3d, 0xac, 0x1c, 0x95, 0xd8, 0xa9, 0xa4, 0x7a, 0xc2, 0xef, 0xd5, 0xdc, 0x26, - 0x2e, 0x6f, 0xc0, 0x73, 0xf0, 0x41, 0x65, 0xaa, 0x51, 0xac, 0x5c, 0x1d, 0x59, 0x5d, 0x0d, 0x34, - 0xf7, 0x4c, 0xb0, 0x5e, 0xcd, 0xd5, 0x41, 0xcc, 0xb6, 0xe0, 0x13, 0x00, 0x66, 0x83, 0x8f, 0xde, - 0x28, 0x3f, 0x1f, 0x2f, 0xfa, 0x79, 0xf1, 0xbc, 0xdf, 0x17, 0xfe, 0x40, 0x85, 0xb3, 0x13, 0x05, - 0x79, 0x5f, 0xd1, 0xb2, 0xe0, 0x5a, 0x0f, 0xd0, 0xd0, 0x5e, 0x85, 0x97, 0xc2, 0xd7, 0xa5, 0x33, - 0x9c, 0xec, 0xa8, 0x12, 0x08, 0x34, 0xb2, 0x77, 0xf4, 0x5c, 0x1a, 0x65, 0x47, 0x15, 0x05, 0x1f, - 0x80, 0x75, 0xa9, 0x17, 0x28, 0x51, 0xf4, 0x7e, 0x85, 0xbe, 0xb8, 0xbc, 0xec, 0xd5, 0x5c, 0xc5, - 0x48, 0x56, 0x0e, 0x3d, 0x4a, 0xed, 0xec, 0x6f, 0x98, 0xcb, 0xfc, 0x15, 0x03, 0x7f, 0x01, 0x7b, - 0xf3, 0x4a, 0x82, 0x32, 0x7b, 0x2f, 0xe4, 0xa9, 0x41, 0x01, 0xc9, 0x5e, 0xa4, 0xe5, 0x0d, 0x78, - 0x1f, 0xd4, 0x53, 0x36, 0x46, 0xb9, 0x3a, 0x7c, 0xa7, 0x72, 0x78, 0x20, 0x53, 0x97, 0x84, 0x7c, - 0x68, 0x85, 0x94, 0xa0, 0xb1, 0xfd, 0xa1, 0xf5, 0x8d, 0x5d, 0x3e, 0xb4, 0x82, 0x95, 0x15, 0xd6, - 0xfa, 0x82, 0xa8, 0xbd, 0xc2, 0x7d, 0x65, 0x95, 0x15, 0xd6, 0x9c, 0x4c, 0x6d, 0x5e, 0x70, 0x10, - 0xb3, 0xa7, 0xa6, 0x87, 0x41, 0xe7, 0x22, 0x2f, 0x6d, 0xd2, 0xf2, 0x06, 0x7c, 0x0a, 0x76, 0xcb, - 0x7a, 0x84, 0xb8, 0xf2, 0xf2, 0x49, 0x55, 0x15, 0xc2, 0x98, 0xe9, 0xe7, 0xd0, 0xab, 0xb9, 0x0d, - 0x3a, 0x5b, 0xc2, 0xe7, 0xa0, 0x39, 0x27, 0x55, 0x48, 0x28, 0x17, 0xf7, 0xac, 0x2e, 0x66, 0x71, - 0xe8, 0x6b, 0x8b, 0x30, 0x8a, 0x4e, 0x4d, 0xa5, 0x1c, 0x4d, 0x96, 0x77, 0xea, 0xd7, 0x02, 0x2a, - 0x3a, 0x35, 0xdd, 0x80, 0x10, 0xac, 0x7b, 0x14, 0xdf, 0xa0, 0x7f, 0xb6, 0x94, 0xc4, 0xd4, 0x5d, - 0x7c, 0x03, 0x8f, 0x40, 0xc3, 0xcb, 0x47, 0x22, 0xf1, 0x09, 0x95, 0x32, 0xf9, 0xef, 0x96, 0xd6, - 0xc9, 0xbe, 0xde, 0x3a, 0x0b, 0x0f, 0x7e, 0x00, 0xcd, 0x39, 0xa9, 0x93, 0xc2, 0x39, 0x24, 0xb7, - 0x46, 0x50, 0xe5, 0x27, 0xdc, 0x07, 0x1b, 0x13, 0x3c, 0x12, 0x04, 0xad, 0xa9, 0x3d, 0xbd, 0x78, - 0xb2, 0xf6, 0xbd, 0xf3, 0x6c, 0x1b, 0x6c, 0x6a, 0xb9, 0x3c, 0xfe, 0xcb, 0x01, 0x8d, 0x57, 0x34, - 0xe6, 0xc4, 0xa8, 0xf3, 0x3e, 0xd8, 0x88, 0xd3, 0x5c, 0x70, 0xe3, 0x47, 0x2f, 0xe0, 0x15, 0xd8, - 0x53, 0x1f, 0xde, 0x54, 0x88, 0xd7, 0x94, 0x10, 0x77, 0x16, 0x33, 0x2d, 0xb9, 0xea, 0x9c, 0xc9, - 0x13, 0xf3, 0x72, 0xdc, 0x8c, 0xcb, 0x7b, 0x07, 0x4f, 0x01, 0xac, 0x42, 0xef, 0x92, 0xc8, 0xf1, - 0xdf, 0x0e, 0x68, 0x9c, 0x52, 0x9a, 0x51, 0x13, 0xfe, 0x63, 0x70, 0x37, 0x0b, 0x02, 0x41, 0x69, - 0x55, 0xe5, 0x1d, 0xad, 0xf2, 0x85, 0xb9, 0xac, 0xf2, 0xfb, 0x60, 0x83, 0x48, 0x27, 0x85, 0x7f, - 0xb5, 0x80, 0xa7, 0xa5, 0xdf, 0x9d, 0xba, 0x4a, 0xf7, 0xab, 0xc5, 0x74, 0x4b, 0x57, 0x2f, 0xfb, - 0xe1, 0x79, 0xe7, 0x46, 0xed, 0x96, 0x1b, 0xf5, 0xd3, 0xef, 0x3f, 0x46, 0x31, 0x97, 0xff, 0x47, - 0x05, 0x59, 0xd2, 0xf5, 0x31, 0x0f, 0xae, 0x83, 0x8c, 0xe6, 0x5d, 0xf3, 0x34, 0x1e, 0xb2, 0xe0, - 0x9a, 0x24, 0x98, 0x75, 0x7d, 0x11, 0x8f, 0xc2, 0x6e, 0x94, 0x75, 0x75, 0x80, 0x5d, 0x13, 0xa0, - 0xbf, 0xa9, 0xd6, 0xdf, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0x94, 0xb4, 0x3c, 0xbd, 0x5f, 0x0a, + // 1010 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x96, 0x5b, 0x73, 0x1b, 0x35, + 0x14, 0xc7, 0xed, 0x38, 0x57, 0x39, 0x0e, 0xa0, 0x06, 0x2a, 0x4c, 0x43, 0x4c, 0xb8, 0xd4, 0x74, + 0xa6, 0x36, 0x94, 0x0e, 0xc3, 0x94, 0xcb, 0x34, 0x2d, 0xa1, 0x0e, 0x99, 0x30, 0xce, 0x3a, 0x99, + 0xce, 0xf0, 0xb2, 0xa3, 0xdd, 0x55, 0x1d, 0xd5, 0xde, 0x8b, 0x75, 0xb1, 0x1b, 0x3e, 0x1b, 0x5f, + 0x84, 0x07, 0xde, 0xe1, 0x5b, 0x30, 0xba, 0xac, 0xbd, 0xb6, 0xe5, 0x30, 0x7d, 0xf2, 0x4a, 0xe7, + 0xa7, 0xa3, 0x73, 0x74, 0x74, 0xfe, 0x32, 0x38, 0x60, 0x24, 0x4c, 0x59, 0xc4, 0xdb, 0x19, 0xf7, + 0xed, 0xa7, 0x1f, 0x60, 0x4e, 0x5a, 0x19, 0x4b, 0x45, 0x0a, 0xf7, 0xf4, 0x0f, 0x6f, 0x59, 0x53, + 0xfd, 0x63, 0x07, 0x3e, 0xc0, 0xaf, 0x06, 0xd8, 0xf0, 0xf5, 0x43, 0x87, 0x9d, 0xe1, 0x20, 0xa0, + 0xc2, 0x02, 0x9f, 0x38, 0x00, 0x1c, 0x0a, 0x3a, 0x26, 0xf1, 0xc8, 0x22, 0x9f, 0xb9, 0x90, 0x09, + 0xf7, 0x07, 0x34, 0x21, 0x9c, 0x72, 0x4b, 0x35, 0x56, 0x50, 0x7c, 0x94, 0x13, 0x4d, 0x17, 0xf1, + 0x87, 0x64, 0xc4, 0x27, 0x63, 0x92, 0x08, 0xff, 0x5a, 0x06, 0x96, 0x7c, 0xb0, 0x92, 0xe4, 0x84, + 0x8d, 0x69, 0x48, 0xfc, 0x40, 0xe6, 0x5e, 0x3f, 0x75, 0xb0, 0xfd, 0x30, 0xf3, 0x33, 0x19, 0xf0, + 0xa9, 0x43, 0xd7, 0x31, 0x0c, 0x64, 0x30, 0xcb, 0xd1, 0x75, 0x8e, 0x71, 0x9a, 0xf4, 0x53, 0x6b, + 0x77, 0x95, 0x25, 0x1e, 0x09, 0x71, 0x8b, 0x39, 0xc1, 0x22, 0x8f, 0xf1, 0xfe, 0x0a, 0xb3, 0xcf, + 0x05, 0x23, 0x38, 0xa6, 0x49, 0xff, 0xff, 0xc0, 0xd7, 0x44, 0x18, 0xd6, 0x82, 0xf7, 0x5c, 0x20, + 0x1f, 0xdd, 0x52, 0xd4, 0x2c, 0xe5, 0xa2, 0xcf, 0x08, 0xbf, 0xe5, 0x44, 0x32, 0x39, 0xe4, 0x98, + 0xdd, 0x12, 0x8a, 0xb9, 0x39, 0x36, 0xea, 0xdc, 0xd3, 0xe7, 0x2e, 0x90, 0x44, 0x94, 0xcf, 0x97, + 0xe0, 0x8b, 0x95, 0xd8, 0x9c, 0xbb, 0xa3, 0xbf, 0xaa, 0x00, 0x78, 0x04, 0x47, 0x9e, 0x66, 0xe0, + 0x01, 0x00, 0x31, 0xe1, 0x1c, 0xf7, 0x89, 0x4f, 0x23, 0x54, 0x6e, 0x94, 0x9b, 0x3b, 0xde, 0x8e, + 0x9d, 0x39, 0x8d, 0xe0, 0xbb, 0xa0, 0x92, 0xc8, 0x18, 0x55, 0x1a, 0xe5, 0x66, 0xc5, 0x53, 0x9f, + 0xf0, 0x67, 0xb0, 0x1d, 0x13, 0x81, 0x23, 0x2c, 0x30, 0x5a, 0x6f, 0x54, 0x9a, 0xd5, 0x47, 0xcd, + 0xd6, 0x7c, 0xd3, 0xb4, 0x66, 0xee, 0x5b, 0xe7, 0x16, 0x3d, 0x49, 0x04, 0xbb, 0xf1, 0xa6, 0x2b, + 0xe1, 0x63, 0x70, 0x97, 0x91, 0x90, 0xd0, 0x31, 0x89, 0x7c, 0x2c, 0x7c, 0x99, 0xd0, 0x37, 0xbe, + 0xe0, 0xbe, 0x14, 0x21, 0xda, 0xd4, 0x7b, 0xdd, 0xc9, 0xcd, 0xc7, 0xe2, 0x2a, 0xa1, 0x6f, 0x2e, + 0xf9, 0x95, 0x08, 0x21, 0x02, 0x5b, 0x19, 0xbe, 0x19, 0xa6, 0x38, 0x42, 0x61, 0xa3, 0xdc, 0xdc, + 0xf5, 0xf2, 0x21, 0x7c, 0x08, 0x36, 0x74, 0x5b, 0xa2, 0xa8, 0x51, 0x6e, 0x56, 0x1f, 0xbd, 0xbf, + 0x18, 0xd2, 0x99, 0x32, 0x76, 0x4a, 0x9e, 0xa1, 0xe0, 0x57, 0x60, 0xd3, 0x9c, 0x35, 0x22, 0x9a, + 0xff, 0x60, 0x29, 0x05, 0x6d, 0xed, 0x94, 0x3c, 0xcb, 0xc1, 0x6f, 0xc1, 0x76, 0xde, 0xb6, 0xe8, + 0x95, 0x5e, 0x83, 0x16, 0xd7, 0x1c, 0x6b, 0xfb, 0xf9, 0x45, 0xa7, 0xe4, 0x4d, 0x59, 0xf8, 0x35, + 0xd8, 0xb2, 0x5d, 0x8a, 0xfa, 0xee, 0xad, 0x8e, 0x5f, 0xf6, 0x7a, 0x17, 0x3d, 0xb5, 0x15, 0x9e, + 0xf0, 0xde, 0x88, 0xc3, 0x17, 0xe0, 0x9d, 0x85, 0xb6, 0x45, 0xd7, 0x7a, 0xe9, 0xc1, 0xd2, 0x52, + 0x85, 0x9d, 0x28, 0xaa, 0x23, 0x83, 0x4e, 0xc9, 0xab, 0xe1, 0xe2, 0x04, 0x3c, 0x07, 0xef, 0x2d, + 0x75, 0x35, 0xa2, 0xda, 0xd5, 0xa1, 0xd3, 0x55, 0xcf, 0x70, 0xcf, 0x24, 0xef, 0x94, 0x3c, 0x13, + 0xc4, 0x6c, 0x0a, 0x3e, 0x01, 0x60, 0xd6, 0xf8, 0xe8, 0xb5, 0xf6, 0xf3, 0xe1, 0xa2, 0x9f, 0x17, + 0xcf, 0xbb, 0x5d, 0x19, 0xf4, 0x74, 0x38, 0x3b, 0xfd, 0x30, 0xeb, 0x6a, 0x5a, 0x1d, 0xb8, 0xd1, + 0x03, 0x34, 0x70, 0x9f, 0xc2, 0x99, 0x0c, 0xcc, 0xd1, 0x59, 0x4e, 0x55, 0x54, 0x0b, 0x04, 0x1a, + 0xba, 0x2b, 0x7a, 0xae, 0x8c, 0xaa, 0xa2, 0x9a, 0x82, 0x0f, 0xc0, 0xba, 0xd2, 0x0b, 0x14, 0x6b, + 0x7a, 0x7f, 0x89, 0xbe, 0xb8, 0xbc, 0xec, 0x94, 0x3c, 0xcd, 0x28, 0x56, 0x35, 0x3d, 0x4a, 0xdc, + 0xec, 0x6f, 0x58, 0xa8, 0xfc, 0x35, 0x03, 0x7f, 0x01, 0x7b, 0xf3, 0x4a, 0x82, 0x52, 0x77, 0x2d, + 0xd4, 0xaa, 0x5e, 0x0e, 0xa9, 0x5a, 0x24, 0xc5, 0x09, 0x78, 0x1f, 0x54, 0x12, 0x3e, 0x42, 0x99, + 0x5e, 0x7c, 0x67, 0x69, 0x71, 0x4f, 0xa5, 0xae, 0x08, 0x75, 0xd1, 0x72, 0x29, 0x41, 0x23, 0xf7, + 0x45, 0xeb, 0x5a, 0xbb, 0xba, 0x68, 0x39, 0xab, 0x4e, 0xd8, 0xe8, 0x0b, 0x62, 0xee, 0x13, 0xee, + 0x6a, 0xab, 0x3a, 0x61, 0xc3, 0xa9, 0xd4, 0xe6, 0x05, 0x07, 0x71, 0x77, 0x6a, 0xa6, 0x19, 0x4c, + 0x2e, 0x6a, 0xd3, 0x1a, 0x2b, 0x4e, 0xc0, 0xa7, 0x60, 0xb7, 0xa8, 0x47, 0x48, 0x68, 0x2f, 0x1f, + 0x2d, 0xab, 0x42, 0x44, 0xb9, 0xb9, 0x0e, 0x9d, 0x92, 0x57, 0x65, 0xb3, 0x21, 0x7c, 0x0e, 0x6a, + 0x73, 0x52, 0x85, 0xa4, 0x76, 0x71, 0xcf, 0xe9, 0x62, 0x16, 0x87, 0xd9, 0x36, 0x0f, 0x23, 0xaf, + 0xd4, 0x54, 0xca, 0xd1, 0x78, 0x75, 0xa5, 0x7e, 0xcd, 0xa1, 0xbc, 0x52, 0xd3, 0x09, 0xf8, 0x23, + 0xa8, 0x16, 0x5e, 0x5f, 0x34, 0xd1, 0x4e, 0xea, 0x8e, 0xae, 0x3d, 0x33, 0x44, 0xa7, 0xe4, 0x01, + 0x3c, 0xe1, 0x76, 0x04, 0x21, 0x58, 0xf7, 0x19, 0x9e, 0xa0, 0x7f, 0xb6, 0xb4, 0x42, 0x55, 0x3c, + 0x3c, 0x81, 0x87, 0xa0, 0xea, 0x67, 0x43, 0x19, 0x07, 0x84, 0x29, 0x95, 0xfd, 0x77, 0xcb, 0xc8, + 0x6c, 0xd7, 0x4c, 0x9d, 0x46, 0xf5, 0xef, 0x41, 0x6d, 0x4e, 0x29, 0x95, 0xee, 0x0e, 0xc8, 0x8d, + 0xd5, 0x63, 0xf5, 0x09, 0xf7, 0xc1, 0xc6, 0x18, 0x0f, 0x25, 0x41, 0x6b, 0x7a, 0xce, 0x0c, 0x9e, + 0xac, 0x7d, 0x57, 0x7e, 0xb6, 0x0d, 0x36, 0x8d, 0xda, 0x1e, 0xfd, 0x59, 0x06, 0xd5, 0x97, 0x8c, + 0x0a, 0x62, 0xc5, 0x7d, 0x1f, 0x6c, 0xd0, 0x24, 0x93, 0xc2, 0xfa, 0x31, 0x03, 0x78, 0x05, 0xf6, + 0xf4, 0x87, 0x3f, 0xd5, 0xf1, 0x35, 0xad, 0xe3, 0xad, 0xc5, 0x1c, 0x0b, 0xae, 0x5a, 0xa7, 0x6a, + 0xc5, 0xbc, 0x9a, 0xd7, 0x68, 0x71, 0xae, 0xfe, 0x14, 0xc0, 0x65, 0xe8, 0x6d, 0x12, 0x39, 0xfa, + 0xbb, 0x0c, 0xaa, 0x27, 0x8c, 0xa5, 0xcc, 0x86, 0xff, 0x18, 0xdc, 0x4d, 0xc3, 0x50, 0x32, 0xb6, + 0xfc, 0x48, 0x94, 0xcd, 0x23, 0x91, 0x9b, 0x8b, 0x8f, 0xc4, 0x3e, 0xd8, 0x20, 0xca, 0x49, 0xee, + 0x5f, 0x0f, 0xe0, 0x49, 0xe1, 0xd9, 0xaa, 0xe8, 0x74, 0xbf, 0x5c, 0x4c, 0xb7, 0xb0, 0xf5, 0xaa, + 0x77, 0xeb, 0xad, 0x0b, 0xb5, 0x5b, 0x2c, 0xd4, 0x4f, 0xbf, 0xff, 0xd0, 0xa7, 0x42, 0xfd, 0x0d, + 0x0b, 0xd3, 0xb8, 0x1d, 0x60, 0x11, 0x5e, 0x87, 0x29, 0xcb, 0xda, 0xf6, 0x6a, 0x3c, 0xe4, 0xe1, + 0x35, 0x89, 0x31, 0x6f, 0x07, 0x92, 0x0e, 0xa3, 0x76, 0x3f, 0x6d, 0x9b, 0x00, 0xdb, 0x36, 0xc0, + 0x60, 0x53, 0x8f, 0xbf, 0xf9, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xe2, 0xad, 0x86, 0x7b, 0xc4, 0x0a, 0x00, 0x00, } diff --git a/vendor/modules.txt b/vendor/modules.txt index aa2916de..4f3a0540 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -113,11 +113,16 @@ github.com/aws/aws-sdk-go/internal/shareddefaults github.com/aws/aws-sdk-go/internal/strings github.com/aws/aws-sdk-go/internal/sync/singleflight github.com/aws/aws-sdk-go/private/protocol +github.com/aws/aws-sdk-go/private/protocol/eventstream +github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi github.com/aws/aws-sdk-go/private/protocol/json/jsonutil +github.com/aws/aws-sdk-go/private/protocol/jsonrpc github.com/aws/aws-sdk-go/private/protocol/query github.com/aws/aws-sdk-go/private/protocol/query/queryutil github.com/aws/aws-sdk-go/private/protocol/rest github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil +github.com/aws/aws-sdk-go/service/kinesis +github.com/aws/aws-sdk-go/service/kinesis/kinesisiface github.com/aws/aws-sdk-go/service/sns github.com/aws/aws-sdk-go/service/sns/snsiface github.com/aws/aws-sdk-go/service/sqs @@ -136,7 +141,7 @@ github.com/batchcorp/kong # github.com/batchcorp/pgoutput v0.3.2 ## explicit github.com/batchcorp/pgoutput -# github.com/batchcorp/plumber-schemas v0.0.120 +# github.com/batchcorp/plumber-schemas v0.0.121 ## explicit github.com/batchcorp/plumber-schemas/build/go/protos github.com/batchcorp/plumber-schemas/build/go/protos/args